'21.07'21.07

189 files changed, 35424 insertions, 0 deletions

diff --git a/CPP/7zip/UI/FileManager/7zFM.exe.manifest b/CPP/7zip/UI/FileManager/7zFM.exe.manifest
new file mode 100644
index 0000000..6a13c92
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/7zFM.exe.manifest
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
+  <assemblyIdentity version="1.0.0.0" processorArchitecture="*" name="7-Zip.7-Zip.7zFM" type="win32"/>
+  <description>7-Zip File Manager.</description>
+  <dependency>
+    <dependentAssembly><assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="*" publicKeyToken="6595b64144ccf1df" language="*"/></dependentAssembly>
+  </dependency>
+<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1"><application>
+<!-- Vista   --> <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
+<!-- Win 7   --> <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
+<!-- Win 8   --> <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
+<!-- Win 8.1 --> <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
+<!-- Win 10  --> <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
+</application></compatibility>
+  <asmv3:application>
+    <asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">
+      <dpiAware>true</dpiAware>
+    </asmv3:windowsSettings>
+  </asmv3:application>
+</assembly>
diff --git a/CPP/7zip/UI/FileManager/7zipLogo.ico b/CPP/7zip/UI/FileManager/7zipLogo.ico
new file mode 100644
index 0000000..973241c
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/7zipLogo.ico
diff --git a/CPP/7zip/UI/FileManager/AboutDialog.cpp b/CPP/7zip/UI/FileManager/AboutDialog.cpp
new file mode 100644
index 0000000..082902e
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/AboutDialog.cpp
@@ -0,0 +1,77 @@
+// AboutDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../MyVersion.h"
+
+#include "../Common/LoadCodecs.h"
+
+#include "AboutDialog.h"
+#include "PropertyNameRes.h"
+
+#include "HelpUtils.h"
+#include "LangUtils.h"
+
+static const UInt32 kLangIDs[] =
+{
+  IDT_ABOUT_INFO
+};
+
+#define kHomePageURL TEXT("https://www.7-zip.org/")
+#define kHelpTopic "start.htm"
+
+#define LLL_(quote) L##quote
+#define LLL(quote) LLL_(quote)
+
+extern CCodecs *g_CodecsObj;
+
+bool CAboutDialog::OnInit()
+{
+  #ifdef EXTERNAL_CODECS
+  if (g_CodecsObj)
+  {
+    UString s;
+    g_CodecsObj->GetCodecsErrorMessage(s);
+    if (!s.IsEmpty())
+      MessageBoxW(GetParent(), s, L"7-Zip", MB_ICONERROR);
+  }
+  #endif
+
+  LangSetDlgItems(*this, kLangIDs, ARRAY_SIZE(kLangIDs));
+  SetItemText(IDT_ABOUT_VERSION, UString("7-Zip " MY_VERSION_CPU));
+  SetItemText(IDT_ABOUT_DATE, LLL(MY_DATE));
+  
+  LangSetWindowText(*this, IDD_ABOUT);
+  NormalizePosition();
+  return CModalDialog::OnInit();
+}
+
+void CAboutDialog::OnHelp()
+{
+  ShowHelpWindow(kHelpTopic);
+}
+
+bool CAboutDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
+{
+  LPCTSTR url;
+  switch (buttonID)
+  {
+    case IDB_ABOUT_HOMEPAGE: url = kHomePageURL; break;
+    default:
+      return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+  }
+
+  #ifdef UNDER_CE
+  SHELLEXECUTEINFO s;
+  memset(&s, 0, sizeof(s));
+  s.cbSize = sizeof(s);
+  s.lpFile = url;
+  ::ShellExecuteEx(&s);
+  #else
+  ::ShellExecute(NULL, NULL, url, NULL, NULL, SW_SHOWNORMAL);
+  #endif
+
+  return true;
+}
diff --git a/CPP/7zip/UI/FileManager/AboutDialog.h b/CPP/7zip/UI/FileManager/AboutDialog.h
new file mode 100644
index 0000000..39fd3ba
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/AboutDialog.h
@@ -0,0 +1,19 @@
+// AboutDialog.h
+ 
+#ifndef __ABOUT_DIALOG_H
+#define __ABOUT_DIALOG_H
+
+#include "../../../Windows/Control/Dialog.h"
+
+#include "AboutDialogRes.h"
+
+class CAboutDialog: public NWindows::NControl::CModalDialog
+{
+public:
+  virtual bool OnInit();
+  virtual void OnHelp();
+  virtual bool OnButtonClicked(int buttonID, HWND buttonHWND);
+  INT_PTR Create(HWND wndParent = 0) { return CModalDialog::Create(IDD_ABOUT, wndParent); }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/AboutDialog.rc b/CPP/7zip/UI/FileManager/AboutDialog.rc
new file mode 100644
index 0000000..b235df0
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/AboutDialog.rc
@@ -0,0 +1,26 @@
+#include "AboutDialogRes.h"
+#include "../../GuiCommon.rc"
+#include "../../MyVersion.h"
+
+#define xc 144
+#define yc 144
+
+#define y 93
+
+IDI_LOGO ICON "../../UI/FileManager/7zipLogo.ico"
+
+#ifndef SS_REALSIZEIMAGE
+#define SS_REALSIZEIMAGE 0x800
+#endif
+
+IDD_ABOUT DIALOG 0, 0, xs, ys  MY_MODAL_DIALOG_STYLE  MY_FONT
+CAPTION "About 7-Zip"
+{
+  DEFPUSHBUTTON  "OK", IDOK, bx1, by, bxs, bys
+  PUSHBUTTON  "www.7-zip.org", IDB_ABOUT_HOMEPAGE, bx2, by, bxs, bys
+  ICON   IDI_LOGO, -1, m, m, 32, 32, SS_REALSIZEIMAGE
+  LTEXT  "", IDT_ABOUT_VERSION, m, 54, xc, 8
+  LTEXT  "", IDT_ABOUT_DATE, m, 67, xc, 8
+  LTEXT  MY_COPYRIGHT, -1, m, 80, xc, 8
+  LTEXT  "7-Zip is free software", IDT_ABOUT_INFO, m, y, xc, (by - y - 1)
+}
diff --git a/CPP/7zip/UI/FileManager/AboutDialogRes.h b/CPP/7zip/UI/FileManager/AboutDialogRes.h
new file mode 100644
index 0000000..b416558
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/AboutDialogRes.h
@@ -0,0 +1,8 @@
+#define IDD_ABOUT  2900
+
+#define IDT_ABOUT_INFO  2901
+
+#define IDI_LOGO             100
+#define IDT_ABOUT_VERSION    101
+#define IDT_ABOUT_DATE       102
+#define IDB_ABOUT_HOMEPAGE   110
diff --git a/CPP/7zip/UI/FileManager/Add.bmp b/CPP/7zip/UI/FileManager/Add.bmp
new file mode 100644
index 0000000..a8577fc
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Add.bmp
diff --git a/CPP/7zip/UI/FileManager/Add2.bmp b/CPP/7zip/UI/FileManager/Add2.bmp
new file mode 100644
index 0000000..252fc25
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Add2.bmp
diff --git a/CPP/7zip/UI/FileManager/AltStreamsFolder.cpp b/CPP/7zip/UI/FileManager/AltStreamsFolder.cpp
new file mode 100644
index 0000000..e1c99d3
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/AltStreamsFolder.cpp
@@ -0,0 +1,839 @@
+// AltStreamsFolder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileIO.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "../Common/ExtractingFilePath.h"
+
+#include "../Agent/IFolderArchive.h"
+
+#include "AltStreamsFolder.h"
+#include "FSDrives.h"
+#include "FSFolder.h"
+
+#include "SysIconUtils.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NFind;
+using namespace NDir;
+using namespace NName;
+
+#ifndef USE_UNICODE_FSTRING
+int CompareFileNames_ForFolderList(const FChar *s1, const FChar *s2);
+#endif
+
+#ifndef UNDER_CE
+
+namespace NFsFolder
+{
+bool MyGetCompressedFileSizeW(CFSTR path, UInt64 &size);
+}
+
+#endif
+
+namespace NAltStreamsFolder {
+
+static const Byte kProps[] =
+{
+  kpidName,
+  kpidSize,
+  kpidPackSize
+};
+
+static unsigned GetFsParentPrefixSize(const FString &path)
+{
+  if (IsNetworkShareRootPath(path))
+    return 0;
+  unsigned prefixSize = GetRootPrefixSize(path);
+  if (prefixSize == 0 || prefixSize >= path.Len())
+    return 0;
+  FString parentPath = path;
+  int pos = parentPath.ReverseFind_PathSepar();
+  if (pos < 0)
+    return 0;
+  if (pos == (int)parentPath.Len() - 1)
+  {
+    parentPath.DeleteBack();
+    pos = parentPath.ReverseFind_PathSepar();
+    if (pos < 0)
+      return 0;
+  }
+  if ((unsigned)pos + 1 < prefixSize)
+    return 0;
+  return pos + 1;
+}
+
+HRESULT CAltStreamsFolder::Init(const FString &path /* , IFolderFolder *parentFolder */)
+{
+   // _parentFolder = parentFolder;
+   if (path.Back() != ':')
+     return E_FAIL;
+
+  _pathPrefix = path;
+  _pathBaseFile = path;
+  _pathBaseFile.DeleteBack();
+
+  {
+    CFileInfo fi;
+    if (!fi.Find(_pathBaseFile))
+      return GetLastError_noZero_HRESULT();
+  }
+
+  unsigned prefixSize = GetFsParentPrefixSize(_pathBaseFile);
+  if (prefixSize == 0)
+    return S_OK;
+  FString parentPath = _pathBaseFile;
+  parentPath.DeleteFrom(prefixSize);
+
+  _findChangeNotification.FindFirst(parentPath, false,
+        FILE_NOTIFY_CHANGE_FILE_NAME
+      | FILE_NOTIFY_CHANGE_DIR_NAME
+      | FILE_NOTIFY_CHANGE_ATTRIBUTES
+      | FILE_NOTIFY_CHANGE_SIZE
+      | FILE_NOTIFY_CHANGE_LAST_WRITE
+      /*
+      | FILE_NOTIFY_CHANGE_LAST_ACCESS
+      | FILE_NOTIFY_CHANGE_CREATION
+      | FILE_NOTIFY_CHANGE_SECURITY
+      */
+      );
+  /*
+  if (_findChangeNotification.IsHandleAllocated())
+    return S_OK;
+  return GetLastError();
+  */
+  return S_OK;
+}
+
+STDMETHODIMP CAltStreamsFolder::LoadItems()
+{
+  Int32 dummy;
+  WasChanged(&dummy);
+  Clear();
+
+  CStreamEnumerator enumerator(_pathBaseFile);
+
+  CStreamInfo si;
+  for (;;)
+  {
+    bool found;
+    if (!enumerator.Next(si, found))
+    {
+      // if (GetLastError() == ERROR_ACCESS_DENIED)
+      //   break;
+      // return E_FAIL;
+      break;
+    }
+    if (!found)
+      break;
+    if (si.IsMainStream())
+      continue;
+    CAltStream ss;
+    ss.Name = si.GetReducedName();
+    if (!ss.Name.IsEmpty() && ss.Name[0] == ':')
+      ss.Name.Delete(0);
+
+    ss.Size = si.Size;
+    ss.PackSize_Defined = false;
+    ss.PackSize = si.Size;
+    Streams.Add(ss);
+  }
+
+  return S_OK;
+}
+
+STDMETHODIMP CAltStreamsFolder::GetNumberOfItems(UInt32 *numItems)
+{
+  *numItems = Streams.Size();
+  return S_OK;
+}
+
+#ifdef USE_UNICODE_FSTRING
+
+STDMETHODIMP CAltStreamsFolder::GetItemPrefix(UInt32 /* index */, const wchar_t **name, unsigned *len)
+{
+  *name = 0;
+  *len = 0;
+  return S_OK;
+}
+
+STDMETHODIMP CAltStreamsFolder::GetItemName(UInt32 index, const wchar_t **name, unsigned *len)
+{
+  *name = 0;
+  *len = 0;
+  {
+    const CAltStream &ss = Streams[index];
+    *name = ss.Name;
+    *len = ss.Name.Len();
+  }
+  return S_OK;
+}
+
+STDMETHODIMP_(UInt64) CAltStreamsFolder::GetItemSize(UInt32 index)
+{
+  return Streams[index].Size;
+}
+
+#endif
+
+
+STDMETHODIMP CAltStreamsFolder::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
+{
+  NCOM::CPropVariant prop;
+  {
+    CAltStream &ss = Streams[index];
+    switch (propID)
+    {
+      case kpidIsDir: prop = false; break;
+      case kpidIsAltStream: prop = true; break;
+      case kpidName: prop = ss.Name; break;
+      case kpidSize: prop = ss.Size; break;
+      case kpidPackSize:
+        #ifdef UNDER_CE
+        prop = ss.Size;
+        #else
+        if (!ss.PackSize_Defined)
+        {
+          ss.PackSize_Defined = true;
+          if (!NFsFolder::MyGetCompressedFileSizeW(_pathPrefix + us2fs(ss.Name), ss.PackSize))
+            ss.PackSize = ss.Size;
+        }
+        prop = ss.PackSize;
+        #endif
+        break;
+    }
+  }
+
+  prop.Detach(value);
+  return S_OK;
+}
+
+
+// returns Position of extension including '.'
+
+static inline const wchar_t *GetExtensionPtr(const UString &name)
+{
+  int dotPos = name.ReverseFind_Dot();
+  return name.Ptr((dotPos < 0) ? name.Len() : dotPos);
+}
+
+STDMETHODIMP_(Int32) CAltStreamsFolder::CompareItems(UInt32 index1, UInt32 index2, PROPID propID, Int32 /* propIsRaw */)
+{
+  const CAltStream &ss1 = Streams[index1];
+  const CAltStream &ss2 = Streams[index2];
+
+  switch (propID)
+  {
+    case kpidName:
+    {
+      return CompareFileNames_ForFolderList(ss1.Name, ss2.Name);
+      // return MyStringCompareNoCase(ss1.Name, ss2.Name);
+    }
+    case kpidSize:
+      return MyCompare(ss1.Size, ss2.Size);
+    case kpidPackSize:
+    {
+      #ifdef UNDER_CE
+      return MyCompare(ss1.Size, ss2.Size);
+      #else
+      // PackSize can be undefined here
+      return MyCompare(
+          ss1.PackSize,
+          ss2.PackSize);
+      #endif
+    }
+    
+    case kpidExtension:
+      return CompareFileNames_ForFolderList(
+          GetExtensionPtr(ss1.Name),
+          GetExtensionPtr(ss2.Name));
+  }
+  
+  return 0;
+}
+
+STDMETHODIMP CAltStreamsFolder::BindToFolder(UInt32 /* index */, IFolderFolder **resultFolder)
+{
+  *resultFolder = 0;
+  return E_INVALIDARG;
+}
+
+STDMETHODIMP CAltStreamsFolder::BindToFolder(const wchar_t * /* name */, IFolderFolder **resultFolder)
+{
+  *resultFolder = 0;
+  return E_INVALIDARG;
+}
+
+// static CFSTR const kSuperPrefix = FTEXT("\\\\?\\");
+
+STDMETHODIMP CAltStreamsFolder::BindToParentFolder(IFolderFolder **resultFolder)
+{
+  *resultFolder = 0;
+  /*
+  if (_parentFolder)
+  {
+    CMyComPtr<IFolderFolder> parentFolder = _parentFolder;
+    *resultFolder = parentFolder.Detach();
+    return S_OK;
+  }
+  */
+
+  if (IsDriveRootPath_SuperAllowed(_pathBaseFile))
+  {
+    CFSDrives *drivesFolderSpec = new CFSDrives;
+    CMyComPtr<IFolderFolder> drivesFolder = drivesFolderSpec;
+    drivesFolderSpec->Init();
+    *resultFolder = drivesFolder.Detach();
+    return S_OK;
+  }
+  
+  /*
+  parentPath.DeleteFrom(pos + 1);
+  
+  if (parentPath == kSuperPrefix)
+  {
+    #ifdef UNDER_CE
+    *resultFolder = 0;
+    #else
+    CFSDrives *drivesFolderSpec = new CFSDrives;
+    CMyComPtr<IFolderFolder> drivesFolder = drivesFolderSpec;
+    drivesFolderSpec->Init(false, true);
+    *resultFolder = drivesFolder.Detach();
+    #endif
+    return S_OK;
+  }
+
+  FString parentPathReduced = parentPath.Left(pos);
+  
+  #ifndef UNDER_CE
+  pos = parentPathReduced.ReverseFind_PathSepar();
+  if (pos == 1)
+  {
+    if (!IS_PATH_SEPAR_CHAR(parentPath[0]))
+      return E_FAIL;
+    CNetFolder *netFolderSpec = new CNetFolder;
+    CMyComPtr<IFolderFolder> netFolder = netFolderSpec;
+    netFolderSpec->Init(fs2us(parentPath));
+    *resultFolder = netFolder.Detach();
+    return S_OK;
+  }
+  #endif
+  
+  CFSFolder *parentFolderSpec = new CFSFolder;
+  CMyComPtr<IFolderFolder> parentFolder = parentFolderSpec;
+  RINOK(parentFolderSpec->Init(parentPath, 0));
+  *resultFolder = parentFolder.Detach();
+  */
+
+  return S_OK;
+}
+
+STDMETHODIMP CAltStreamsFolder::GetNumberOfProperties(UInt32 *numProperties)
+{
+  *numProperties = ARRAY_SIZE(kProps);
+  return S_OK;
+}
+
+STDMETHODIMP CAltStreamsFolder::GetPropertyInfo IMP_IFolderFolder_GetProp(kProps)
+
+STDMETHODIMP CAltStreamsFolder::GetFolderProperty(PROPID propID, PROPVARIANT *value)
+{
+  COM_TRY_BEGIN
+  NWindows::NCOM::CPropVariant prop;
+  switch (propID)
+  {
+    case kpidType: prop = "AltStreamsFolder"; break;
+    case kpidPath: prop = fs2us(_pathPrefix); break;
+  }
+  prop.Detach(value);
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CAltStreamsFolder::WasChanged(Int32 *wasChanged)
+{
+  bool wasChangedMain = false;
+  for (;;)
+  {
+    if (!_findChangeNotification.IsHandleAllocated())
+    {
+      *wasChanged = BoolToInt(false);
+      return S_OK;
+    }
+
+    DWORD waitResult = ::WaitForSingleObject(_findChangeNotification, 0);
+    bool wasChangedLoc = (waitResult == WAIT_OBJECT_0);
+    if (wasChangedLoc)
+    {
+      _findChangeNotification.FindNext();
+      wasChangedMain = true;
+    }
+    else
+      break;
+  }
+  *wasChanged = BoolToInt(wasChangedMain);
+  return S_OK;
+}
+ 
+STDMETHODIMP CAltStreamsFolder::Clone(IFolderFolder **resultFolder)
+{
+  CAltStreamsFolder *folderSpec = new CAltStreamsFolder;
+  CMyComPtr<IFolderFolder> folderNew = folderSpec;
+  folderSpec->Init(_pathPrefix);
+  *resultFolder = folderNew.Detach();
+  return S_OK;
+}
+
+void CAltStreamsFolder::GetAbsPath(const wchar_t *name, FString &absPath)
+{
+  absPath.Empty();
+  if (!IsAbsolutePath(name))
+    absPath += _pathPrefix;
+  absPath += us2fs(name);
+}
+
+
+
+static HRESULT SendMessageError(IFolderOperationsExtractCallback *callback,
+    const wchar_t *message, const FString &fileName)
+{
+  UString s = message;
+  s += " : ";
+  s += fs2us(fileName);
+  return callback->ShowMessage(s);
+}
+
+static HRESULT SendMessageError(IFolderArchiveUpdateCallback *callback,
+    const wchar_t *message, const FString &fileName)
+{
+  UString s = message;
+  s += " : ";
+  s += fs2us(fileName);
+  return callback->UpdateErrorMessage(s);
+}
+
+static HRESULT SendMessageError(IFolderOperationsExtractCallback *callback,
+    const char *message, const FString &fileName)
+{
+  return SendMessageError(callback, MultiByteToUnicodeString(message), fileName);
+}
+
+/*
+static HRESULT SendMessageError(IFolderArchiveUpdateCallback *callback,
+    const char *message, const FString &fileName)
+{
+  return SendMessageError(callback, MultiByteToUnicodeString(message), fileName);
+}
+*/
+
+STDMETHODIMP CAltStreamsFolder::CreateFolder(const wchar_t * /* name */, IProgress * /* progress */)
+{
+  return E_NOTIMPL;
+}
+
+STDMETHODIMP CAltStreamsFolder::CreateFile(const wchar_t *name, IProgress * /* progress */)
+{
+  FString absPath;
+  GetAbsPath(name, absPath);
+  NIO::COutFile outFile;
+  if (!outFile.Create(absPath, false))
+    return ::GetLastError();
+  return S_OK;
+}
+
+static DWORD Return_LastError_or_FAIL()
+{
+  DWORD errorCode = GetLastError();
+  if (errorCode == 0)
+    errorCode = (DWORD)E_FAIL;
+  return errorCode;
+}
+
+static UString GetLastErrorMessage()
+{
+  return NError::MyFormatMessage(Return_LastError_or_FAIL());
+}
+
+static HRESULT UpdateFile(NFsFolder::CCopyStateIO &state, CFSTR inPath, CFSTR outPath, IFolderArchiveUpdateCallback *callback)
+{
+  if (NFind::DoesFileOrDirExist(outPath))
+  {
+    RINOK(SendMessageError(callback, NError::MyFormatMessage(ERROR_ALREADY_EXISTS), FString(outPath)));
+    CFileInfo fi;
+    if (fi.Find(inPath))
+    {
+      if (state.TotalSize >= fi.Size)
+        state.TotalSize -= fi.Size;
+    }
+    return S_OK;
+  }
+
+  {
+    if (callback)
+      RINOK(callback->CompressOperation(fs2us(inPath)));
+    RINOK(state.MyCopyFile(inPath, outPath));
+    if (state.ErrorFileIndex >= 0)
+    {
+      if (state.ErrorMessage.IsEmpty())
+        state.ErrorMessage = GetLastErrorMessage();
+      FString errorName;
+      if (state.ErrorFileIndex == 0)
+        errorName = inPath;
+      else
+        errorName = outPath;
+      if (callback)
+        RINOK(SendMessageError(callback, state.ErrorMessage, errorName));
+    }
+    if (callback)
+      RINOK(callback->OperationResult(0));
+  }
+
+  return S_OK;
+}
+
+STDMETHODIMP CAltStreamsFolder::Rename(UInt32 index, const wchar_t *newName, IProgress *progress)
+{
+  CMyComPtr<IFolderArchiveUpdateCallback> callback;
+  if (progress)
+  {
+    RINOK(progress->QueryInterface(IID_IFolderArchiveUpdateCallback, (void **)&callback));
+  }
+
+  FString destPath = _pathPrefix + us2fs(newName);
+
+  const CAltStream &ss = Streams[index];
+
+  if (callback)
+  {
+    RINOK(callback->SetNumFiles(1));
+    RINOK(callback->SetTotal(ss.Size));
+  }
+
+  NFsFolder::CCopyStateIO state;
+  state.Progress = progress;
+  state.TotalSize = 0;
+  state.DeleteSrcFile = true;
+
+  return UpdateFile(state, _pathPrefix + us2fs(ss.Name), destPath, callback);
+}
+
+STDMETHODIMP CAltStreamsFolder::Delete(const UInt32 *indices, UInt32 numItems,IProgress *progress)
+{
+  RINOK(progress->SetTotal(numItems));
+  for (UInt32 i = 0; i < numItems; i++)
+  {
+    const CAltStream &ss = Streams[indices[i]];
+    const FString fullPath = _pathPrefix + us2fs(ss.Name);
+    bool result = DeleteFileAlways(fullPath);
+    if (!result)
+      return Return_LastError_or_FAIL();
+    UInt64 completed = i;
+    RINOK(progress->SetCompleted(&completed));
+  }
+  return S_OK;
+}
+
+STDMETHODIMP CAltStreamsFolder::SetProperty(UInt32 /* index */, PROPID /* propID */,
+    const PROPVARIANT * /* value */, IProgress * /* progress */)
+{
+  return E_NOTIMPL;
+}
+
+STDMETHODIMP CAltStreamsFolder::GetSystemIconIndex(UInt32 index, Int32 *iconIndex)
+{
+  const CAltStream &ss = Streams[index];
+  *iconIndex = 0;
+  int iconIndexTemp;
+  if (GetRealIconIndex(_pathPrefix + us2fs(ss.Name),
+    0 // fi.Attrib
+    , iconIndexTemp) != 0)
+  {
+    *iconIndex = iconIndexTemp;
+    return S_OK;
+  }
+  return Return_LastError_or_FAIL();
+}
+
+/*
+class CGetProp:
+  public IGetProp,
+  public CMyUnknownImp
+{
+public:
+  // const CArc *Arc;
+  // UInt32 IndexInArc;
+  UString Name; // relative path
+  UInt64 Size;
+
+  MY_UNKNOWN_IMP1(IGetProp)
+  INTERFACE_IGetProp(;)
+};
+
+STDMETHODIMP CGetProp::GetProp(PROPID propID, PROPVARIANT *value)
+{
+  if (propID == kpidName)
+  {
+    COM_TRY_BEGIN
+    NCOM::CPropVariant prop = Name;
+    prop.Detach(value);
+    return S_OK;
+    COM_TRY_END
+  }
+  if (propID == kpidSize)
+  {
+    NCOM::CPropVariant prop = Size;
+    prop.Detach(value);
+    return S_OK;
+  }
+  NCOM::CPropVariant prop;
+  prop.Detach(value);
+  return S_OK;
+}
+*/
+
+static HRESULT CopyStream(
+    NFsFolder::CCopyStateIO &state,
+    const FString &srcPath,
+    const CFileInfo &srcFileInfo,
+    const CAltStream &srcAltStream,
+    const FString &destPathSpec,
+    IFolderOperationsExtractCallback *callback)
+{
+  FString destPath = destPathSpec;
+  if (CompareFileNames(destPath, srcPath) == 0)
+  {
+    RINOK(SendMessageError(callback, "Cannot copy file onto itself", destPath));
+    return E_ABORT;
+  }
+
+  Int32 writeAskResult;
+  CMyComBSTR destPathResult;
+  RINOK(callback->AskWrite(
+      fs2us(srcPath),
+      BoolToInt(false),
+      &srcFileInfo.MTime, &srcAltStream.Size,
+      fs2us(destPath),
+      &destPathResult,
+      &writeAskResult));
+
+  if (IntToBool(writeAskResult))
+  {
+    RINOK(callback->SetCurrentFilePath(fs2us(srcPath)));
+    FString destPathNew (us2fs((LPCOLESTR)destPathResult));
+    RINOK(state.MyCopyFile(srcPath, destPathNew));
+    if (state.ErrorFileIndex >= 0)
+    {
+      if (state.ErrorMessage.IsEmpty())
+        state.ErrorMessage = GetLastErrorMessage();
+      FString errorName;
+      if (state.ErrorFileIndex == 0)
+        errorName = srcPath;
+      else
+        errorName = destPathNew;
+      RINOK(SendMessageError(callback, state.ErrorMessage, errorName));
+      return E_ABORT;
+    }
+    state.StartPos += state.CurrentSize;
+  }
+  else
+  {
+    if (state.TotalSize >= srcAltStream.Size)
+    {
+      state.TotalSize -= srcAltStream.Size;
+      RINOK(state.Progress->SetTotal(state.TotalSize));
+    }
+  }
+  return S_OK;
+}
+
+STDMETHODIMP CAltStreamsFolder::CopyTo(Int32 moveMode, const UInt32 *indices, UInt32 numItems,
+    Int32 /* includeAltStreams */, Int32 /* replaceAltStreamColon */,
+    const wchar_t *path, IFolderOperationsExtractCallback *callback)
+{
+  if (numItems == 0)
+    return S_OK;
+
+  /*
+  CMyComPtr<IFolderExtractToStreamCallback> ExtractToStreamCallback;
+  RINOK(callback->QueryInterface(IID_IFolderExtractToStreamCallback, (void **)&ExtractToStreamCallback));
+  if (ExtractToStreamCallback)
+  {
+    Int32 useStreams = 0;
+    if (ExtractToStreamCallback->UseExtractToStream(&useStreams) != S_OK)
+      useStreams = 0;
+    if (useStreams == 0)
+      ExtractToStreamCallback.Release();
+  }
+  */
+
+  UInt64 totalSize = 0;
+  {
+    UInt32 i;
+    for (i = 0; i < numItems; i++)
+    {
+      totalSize += Streams[indices[i]].Size;
+    }
+    RINOK(callback->SetTotal(totalSize));
+    RINOK(callback->SetNumFiles(numItems));
+  }
+
+  /*
+  if (ExtractToStreamCallback)
+  {
+    CGetProp *GetProp_Spec = new CGetProp;
+    CMyComPtr<IGetProp> GetProp= GetProp_Spec;
+
+    for (UInt32 i = 0; i < numItems; i++)
+    {
+      UInt32 index = indices[i];
+      const CAltStream &ss = Streams[index];
+      GetProp_Spec->Name = ss.Name;
+      GetProp_Spec->Size = ss.Size;
+      CMyComPtr<ISequentialOutStream> outStream;
+      RINOK(ExtractToStreamCallback->GetStream7(GetProp_Spec->Name, BoolToInt(false), &outStream,
+        NArchive::NExtract::NAskMode::kExtract, GetProp)); // isDir
+      FString srcPath;
+      GetFullPath(ss, srcPath);
+      RINOK(ExtractToStreamCallback->PrepareOperation7(NArchive::NExtract::NAskMode::kExtract));
+      RINOK(ExtractToStreamCallback->SetOperationResult7(NArchive::NExtract::NOperationResult::kOK, BoolToInt(false))); // _encrypted
+      // RINOK(CopyStream(state, srcPath, fi, ss, destPath2, callback, completedSize));
+    }
+    return S_OK;
+  }
+  */
+
+  FString destPath (us2fs(path));
+  if (destPath.IsEmpty() /* && !ExtractToStreamCallback */)
+    return E_INVALIDARG;
+
+  bool isAltDest = NName::IsAltPathPrefix(destPath);
+  bool isDirectPath = (!isAltDest && !IsPathSepar(destPath.Back()));
+
+  if (isDirectPath)
+  {
+    if (numItems > 1)
+      return E_INVALIDARG;
+  }
+
+  CFileInfo fi;
+  if (!fi.Find(_pathBaseFile))
+    return GetLastError();
+
+  NFsFolder::CCopyStateIO state;
+  state.Progress = callback;
+  state.DeleteSrcFile = IntToBool(moveMode);
+  state.TotalSize = totalSize;
+
+  for (UInt32 i = 0; i < numItems; i++)
+  {
+    UInt32 index = indices[i];
+    const CAltStream &ss = Streams[index];
+    FString destPath2 = destPath;
+    if (!isDirectPath)
+      destPath2 += us2fs(Get_Correct_FsFile_Name(ss.Name));
+    FString srcPath;
+    GetFullPath(ss, srcPath);
+    RINOK(CopyStream(state, srcPath, fi, ss, destPath2, callback));
+  }
+
+  return S_OK;
+}
+
+STDMETHODIMP CAltStreamsFolder::CopyFrom(Int32 /* moveMode */, const wchar_t * /* fromFolderPath */,
+    const wchar_t * const * /* itemsPaths */, UInt32 /* numItems */, IProgress * /* progress */)
+{
+  /*
+  if (numItems == 0)
+    return S_OK;
+
+  CMyComPtr<IFolderArchiveUpdateCallback> callback;
+  if (progress)
+  {
+    RINOK(progress->QueryInterface(IID_IFolderArchiveUpdateCallback, (void **)&callback));
+  }
+
+  if (CompareFileNames(fromFolderPath, fs2us(_pathPrefix)) == 0)
+  {
+    RINOK(SendMessageError(callback, "Cannot copy file onto itself", _pathPrefix));
+    return E_ABORT;
+  }
+
+  if (callback)
+    RINOK(callback->SetNumFiles(numItems));
+
+  UInt64 totalSize = 0;
+  
+  UInt32 i;
+  
+  FString path;
+  for (i = 0; i < numItems; i++)
+  {
+    path = us2fs(fromFolderPath);
+    path += us2fs(itemsPaths[i]);
+
+    CFileInfo fi;
+    if (!fi.Find(path))
+      return ::GetLastError();
+    if (fi.IsDir())
+      return E_NOTIMPL;
+    totalSize += fi.Size;
+  }
+  
+  RINOK(progress->SetTotal(totalSize));
+
+  // UInt64 completedSize = 0;
+   
+  NFsFolder::CCopyStateIO state;
+  state.Progress = progress;
+  state.DeleteSrcFile = IntToBool(moveMode);
+  state.TotalSize = totalSize;
+
+  // we need to clear READ-ONLY of parent before creating alt stream
+  {
+    DWORD attrib = GetFileAttrib(_pathBaseFile);
+    if (attrib != INVALID_FILE_ATTRIBUTES
+        && (attrib & FILE_ATTRIBUTE_READONLY) != 0)
+    {
+      if (!SetFileAttrib(_pathBaseFile, attrib & ~FILE_ATTRIBUTE_READONLY))
+      {
+        if (callback)
+        {
+          RINOK(SendMessageError(callback, GetLastErrorMessage(), _pathBaseFile));
+          return S_OK;
+        }
+        return Return_LastError_or_FAIL();
+      }
+    }
+  }
+  
+  for (i = 0; i < numItems; i++)
+  {
+    path = us2fs(fromFolderPath);
+    path += us2fs(itemsPaths[i]);
+
+    FString destPath = _pathPrefix + us2fs(itemsPaths[i]);
+
+    RINOK(UpdateFile(state, path, destPath, callback));
+  }
+
+  return S_OK;
+  */
+  return E_NOTIMPL;
+}
+
+STDMETHODIMP CAltStreamsFolder::CopyFromFile(UInt32 /* index */, const wchar_t * /* fullFilePath */, IProgress * /* progress */)
+{
+  return E_NOTIMPL;
+}
+
+}
diff --git a/CPP/7zip/UI/FileManager/AltStreamsFolder.h b/CPP/7zip/UI/FileManager/AltStreamsFolder.h
new file mode 100644
index 0000000..ccd0a58
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/AltStreamsFolder.h
@@ -0,0 +1,100 @@
+// AltStreamsFolder.h
+
+#ifndef __ALT_STREAMS_FOLDER_H
+#define __ALT_STREAMS_FOLDER_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../../Windows/FileFind.h"
+
+#include "../../Archive/IArchive.h"
+
+#include "IFolder.h"
+
+namespace NAltStreamsFolder {
+
+class CAltStreamsFolder;
+
+struct CAltStream
+{
+  UInt64 Size;
+  UInt64 PackSize;
+  bool PackSize_Defined;
+  UString Name;
+};
+
+
+class CAltStreamsFolder:
+  public IFolderFolder,
+  public IFolderCompare,
+  #ifdef USE_UNICODE_FSTRING
+  public IFolderGetItemName,
+  #endif
+  public IFolderWasChanged,
+  public IFolderOperations,
+  // public IFolderOperationsDeleteToRecycleBin,
+  public IFolderClone,
+  public IFolderGetSystemIconIndex,
+  public CMyUnknownImp
+{
+public:
+  MY_QUERYINTERFACE_BEGIN2(IFolderFolder)
+    MY_QUERYINTERFACE_ENTRY(IFolderCompare)
+    #ifdef USE_UNICODE_FSTRING
+    MY_QUERYINTERFACE_ENTRY(IFolderGetItemName)
+    #endif
+    MY_QUERYINTERFACE_ENTRY(IFolderWasChanged)
+    // MY_QUERYINTERFACE_ENTRY(IFolderOperationsDeleteToRecycleBin)
+    MY_QUERYINTERFACE_ENTRY(IFolderOperations)
+    MY_QUERYINTERFACE_ENTRY(IFolderClone)
+    MY_QUERYINTERFACE_ENTRY(IFolderGetSystemIconIndex)
+  MY_QUERYINTERFACE_END
+  MY_ADDREF_RELEASE
+
+
+  INTERFACE_FolderFolder(;)
+  INTERFACE_FolderOperations(;)
+
+  STDMETHOD_(Int32, CompareItems)(UInt32 index1, UInt32 index2, PROPID propID, Int32 propIsRaw);
+
+  #ifdef USE_UNICODE_FSTRING
+  INTERFACE_IFolderGetItemName(;)
+  #endif
+  STDMETHOD(WasChanged)(Int32 *wasChanged);
+  STDMETHOD(Clone)(IFolderFolder **resultFolder);
+
+  STDMETHOD(GetSystemIconIndex)(UInt32 index, Int32 *iconIndex);
+
+private:
+  FString _pathBaseFile;  // folder
+  FString _pathPrefix;    // folder:
+  
+  CObjectVector<CAltStream> Streams;
+  // CMyComPtr<IFolderFolder> _parentFolder;
+
+  NWindows::NFile::NFind::CFindChangeNotification _findChangeNotification;
+
+  HRESULT GetItemFullSize(unsigned index, UInt64 &size, IProgress *progress);
+  void GetAbsPath(const wchar_t *name, FString &absPath);
+
+public:
+  // path must be with ':' at tail
+  HRESULT Init(const FString &path /* , IFolderFolder *parentFolder */);
+
+  CAltStreamsFolder() {}
+
+  void GetFullPath(const CAltStream &item, FString &path) const
+  {
+    path = _pathPrefix;
+    path += us2fs(item.Name);
+  }
+
+  void Clear()
+  {
+    Streams.Clear();
+  }
+};
+
+}
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/App.cpp b/CPP/7zip/UI/FileManager/App.cpp
new file mode 100644
index 0000000..512acc5
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/App.cpp
@@ -0,0 +1,998 @@
+// App.cpp
+
+#include "StdAfx.h"
+
+#include "resource.h"
+#include "OverwriteDialogRes.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariantConv.h"
+
+/*
+#include "Windows/COM.h"
+#include "Windows/Error.h"
+#include "Windows/FileDir.h"
+
+#include "Windows/PropVariant.h"
+#include "Windows/Thread.h"
+*/
+
+#include "App.h"
+#include "CopyDialog.h"
+#include "ExtractCallback.h"
+#include "FormatUtils.h"
+#include "IFolder.h"
+#include "LangUtils.h"
+#include "MyLoadMenu.h"
+#include "RegistryUtils.h"
+#include "ViewSettings.h"
+
+#include "PropertyNameRes.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+using namespace NFind;
+using namespace NName;
+
+extern DWORD g_ComCtl32Version;
+extern HINSTANCE g_hInstance;
+
+#define kTempDirPrefix FTEXT("7zE")
+
+void CPanelCallbackImp::OnTab()
+{
+  if (g_App.NumPanels != 1)
+    _app->Panels[1 - _index].SetFocusToList();
+  _app->RefreshTitle();
+}
+
+void CPanelCallbackImp::SetFocusToPath(unsigned index)
+{
+  int newPanelIndex = index;
+  if (g_App.NumPanels == 1)
+    newPanelIndex = g_App.LastFocusedPanel;
+  _app->RefreshTitle();
+  _app->Panels[newPanelIndex]._headerComboBox.SetFocus();
+  _app->Panels[newPanelIndex]._headerComboBox.ShowDropDown();
+}
+
+
+void CPanelCallbackImp::OnCopy(bool move, bool copyToSame) { _app->OnCopy(move, copyToSame, _index); }
+void CPanelCallbackImp::OnSetSameFolder() { _app->OnSetSameFolder(_index); }
+void CPanelCallbackImp::OnSetSubFolder()  { _app->OnSetSubFolder(_index); }
+void CPanelCallbackImp::PanelWasFocused() { _app->SetFocusedPanel(_index); _app->RefreshTitlePanel(_index); }
+void CPanelCallbackImp::DragBegin() { _app->DragBegin(_index); }
+void CPanelCallbackImp::DragEnd() { _app->DragEnd(); }
+void CPanelCallbackImp::RefreshTitle(bool always) { _app->RefreshTitlePanel(_index, always); }
+
+void CApp::ReloadLang()
+{
+  LangString(IDS_N_SELECTED_ITEMS, LangString_N_SELECTED_ITEMS);
+}
+
+void CApp::SetListSettings()
+{
+  CFmSettings st;
+  st.Load();
+
+  ShowSystemMenu = st.ShowSystemMenu;
+
+  DWORD extendedStyle = LVS_EX_HEADERDRAGDROP;
+  if (st.FullRow)
+    extendedStyle |= LVS_EX_FULLROWSELECT;
+  if (st.ShowGrid)
+    extendedStyle |= LVS_EX_GRIDLINES;
+  
+  if (st.SingleClick)
+  {
+    extendedStyle |= LVS_EX_ONECLICKACTIVATE | LVS_EX_TRACKSELECT;
+    /*
+    if (ReadUnderline())
+      extendedStyle |= LVS_EX_UNDERLINEHOT;
+    */
+  }
+
+  for (unsigned i = 0; i < kNumPanelsMax; i++)
+  {
+    CPanel &panel = Panels[i];
+    panel._mySelectMode = st.AlternativeSelection;
+    panel._showDots = st.ShowDots;
+    panel._showRealFileIcons = st.ShowRealFileIcons;
+    panel._exStyle = extendedStyle;
+
+    DWORD style = (DWORD)panel._listView.GetStyle();
+    if (st.AlternativeSelection)
+      style |= LVS_SINGLESEL;
+    else
+      style &= ~LVS_SINGLESEL;
+    panel._listView.SetStyle(style);
+    panel.SetExtendedStyle();
+  }
+}
+
+#ifndef ILC_COLOR32
+#define ILC_COLOR32 0x0020
+#endif
+
+HRESULT CApp::CreateOnePanel(int panelIndex, const UString &mainPath, const UString &arcFormat,
+    bool needOpenArc,
+    COpenResult &openRes)
+{
+  if (Panels[panelIndex].PanelCreated)
+    return S_OK;
+  
+  m_PanelCallbackImp[panelIndex].Init(this, panelIndex);
+  
+  UString path;
+  if (mainPath.IsEmpty())
+  {
+    if (!::ReadPanelPath(panelIndex, path))
+      path.Empty();
+  }
+  else
+    path = mainPath;
+  
+  int id = 1000 + 100 * panelIndex;
+
+  return Panels[panelIndex].Create(_window, _window,
+      id, path, arcFormat, &m_PanelCallbackImp[panelIndex], &AppState,
+      needOpenArc,
+      openRes);
+}
+
+
+static void CreateToolbar(HWND parent,
+    NControl::CImageList &imageList,
+    NControl::CToolBar &toolBar,
+    bool largeButtons)
+{
+  toolBar.Attach(::CreateWindowEx(0, TOOLBARCLASSNAME, NULL, 0
+      | WS_CHILD
+      | WS_VISIBLE
+      | TBSTYLE_FLAT
+      | TBSTYLE_TOOLTIPS
+      | TBSTYLE_WRAPABLE
+      // | TBSTYLE_AUTOSIZE
+      // | CCS_NORESIZE
+      #ifdef UNDER_CE
+      | CCS_NODIVIDER
+      | CCS_NOPARENTALIGN
+      #endif
+      ,0,0,0,0, parent, NULL, g_hInstance, NULL));
+
+  // TB_BUTTONSTRUCTSIZE message, which is required for
+  // backward compatibility.
+  toolBar.ButtonStructSize();
+
+  imageList.Create(
+      largeButtons ? 48: 24,
+      largeButtons ? 36: 24,
+      ILC_MASK | ILC_COLOR32, 0, 0);
+  toolBar.SetImageList(0, imageList);
+}
+
+
+struct CButtonInfo
+{
+  int CommandID;
+  UINT BitmapResID;
+  UINT Bitmap2ResID;
+  UINT StringResID;
+
+  UString GetText() const { return LangString(StringResID); }
+};
+
+static const CButtonInfo g_StandardButtons[] =
+{
+  { IDM_COPY_TO,    IDB_COPY,   IDB_COPY2,   IDS_BUTTON_COPY },
+  { IDM_MOVE_TO,    IDB_MOVE,   IDB_MOVE2,   IDS_BUTTON_MOVE },
+  { IDM_DELETE,     IDB_DELETE, IDB_DELETE2, IDS_BUTTON_DELETE } ,
+  { IDM_PROPERTIES, IDB_INFO,   IDB_INFO2,   IDS_BUTTON_INFO }
+};
+
+static const CButtonInfo g_ArchiveButtons[] =
+{
+  { kMenuCmdID_Toolbar_Add,     IDB_ADD,     IDB_ADD2,     IDS_ADD },
+  { kMenuCmdID_Toolbar_Extract, IDB_EXTRACT, IDB_EXTRACT2, IDS_EXTRACT },
+  { kMenuCmdID_Toolbar_Test,    IDB_TEST,    IDB_TEST2,    IDS_TEST }
+};
+
+static bool SetButtonText(int commandID, const CButtonInfo *buttons, unsigned numButtons, UString &s)
+{
+  for (unsigned i = 0; i < numButtons; i++)
+  {
+    const CButtonInfo &b = buttons[i];
+    if (b.CommandID == commandID)
+    {
+      s = b.GetText();
+      return true;
+    }
+  }
+  return false;
+}
+
+static void SetButtonText(int commandID, UString &s)
+{
+  if (SetButtonText(commandID, g_StandardButtons, ARRAY_SIZE(g_StandardButtons), s))
+    return;
+  SetButtonText(commandID, g_ArchiveButtons, ARRAY_SIZE(g_ArchiveButtons), s);
+}
+
+static void AddButton(
+    NControl::CImageList &imageList,
+    NControl::CToolBar &toolBar,
+    const CButtonInfo &butInfo, bool showText, bool large)
+{
+  TBBUTTON but;
+  but.iBitmap = 0;
+  but.idCommand = butInfo.CommandID;
+  but.fsState = TBSTATE_ENABLED;
+  but.fsStyle = TBSTYLE_BUTTON;
+  but.dwData = 0;
+
+  UString s = butInfo.GetText();
+  but.iString = 0;
+  if (showText)
+    but.iString = (INT_PTR)(LPCWSTR)s;
+
+  but.iBitmap = imageList.GetImageCount();
+  HBITMAP b = ::LoadBitmap(g_hInstance,
+      large ?
+      MAKEINTRESOURCE(butInfo.BitmapResID):
+      MAKEINTRESOURCE(butInfo.Bitmap2ResID));
+  if (b != 0)
+  {
+    imageList.AddMasked(b, RGB(255, 0, 255));
+    ::DeleteObject(b);
+  }
+  #ifdef _UNICODE
+  toolBar.AddButton(1, &but);
+  #else
+  toolBar.AddButtonW(1, &but);
+  #endif
+}
+
+void CApp::ReloadToolbars()
+{
+  _buttonsImageList.Destroy();
+  _toolBar.Destroy();
+
+
+  if (ShowArchiveToolbar || ShowStandardToolbar)
+  {
+    CreateToolbar(_window, _buttonsImageList, _toolBar, LargeButtons);
+    unsigned i;
+    if (ShowArchiveToolbar)
+      for (i = 0; i < ARRAY_SIZE(g_ArchiveButtons); i++)
+        AddButton(_buttonsImageList, _toolBar, g_ArchiveButtons[i], ShowButtonsLables, LargeButtons);
+    if (ShowStandardToolbar)
+      for (i = 0; i < ARRAY_SIZE(g_StandardButtons); i++)
+        AddButton(_buttonsImageList, _toolBar, g_StandardButtons[i], ShowButtonsLables, LargeButtons);
+
+    _toolBar.AutoSize();
+  }
+}
+
+void CApp::SaveToolbarChanges()
+{
+  SaveToolbar();
+  ReloadToolbars();
+  MoveSubWindows();
+}
+
+
+HRESULT CApp::Create(HWND hwnd, const UString &mainPath, const UString &arcFormat, int xSizes[2], bool needOpenArc, COpenResult &openRes)
+{
+  _window.Attach(hwnd);
+
+  #ifdef UNDER_CE
+  _commandBar.Create(g_hInstance, hwnd, 1);
+  #endif
+
+  MyLoadMenu();
+  
+  #ifdef UNDER_CE
+  _commandBar.AutoSize();
+  #endif
+
+  ReadToolbar();
+  ReloadToolbars();
+
+  unsigned i;
+  for (i = 0; i < kNumPanelsMax; i++)
+    Panels[i].PanelCreated = false;
+
+  AppState.Read();
+  
+  SetListSettings();
+
+  if (LastFocusedPanel >= kNumPanelsMax)
+    LastFocusedPanel = 0;
+  // ShowDeletedFiles = Read_ShowDeleted();
+
+  CListMode listMode;
+  listMode.Read();
+  
+  for (i = 0; i < kNumPanelsMax; i++)
+  {
+    CPanel &panel = Panels[i];
+    panel._ListViewMode = listMode.Panels[i];
+    panel._xSize = xSizes[i];
+    panel._flatModeForArc = ReadFlatView(i);
+  }
+  
+  for (i = 0; i < kNumPanelsMax; i++)
+  {
+    unsigned panelIndex = i;
+    if (needOpenArc && LastFocusedPanel == 1)
+      panelIndex = 1 - i;
+
+    bool isMainPanel = (panelIndex == LastFocusedPanel);
+
+    if (NumPanels > 1 || isMainPanel)
+    {
+      if (NumPanels == 1)
+        Panels[panelIndex]._xSize = xSizes[0] + xSizes[1];
+      
+      COpenResult openRes2;
+      UString path;
+      if (isMainPanel)
+        path = mainPath;
+      
+      RINOK(CreateOnePanel(panelIndex, path, arcFormat,
+          isMainPanel && needOpenArc,
+          *(isMainPanel ? &openRes : &openRes2)));
+      
+      if (isMainPanel)
+      {
+        if (needOpenArc && !openRes.ArchiveIsOpened)
+          return S_OK;
+      }
+    }
+  }
+  
+  SetFocusedPanel(LastFocusedPanel);
+  Panels[LastFocusedPanel].SetFocusToList();
+  return S_OK;
+}
+
+
+HRESULT CApp::SwitchOnOffOnePanel()
+{
+  if (NumPanels == 1)
+  {
+    NumPanels++;
+    COpenResult openRes;
+    RINOK(CreateOnePanel(1 - LastFocusedPanel, UString(), UString(),
+        false, // needOpenArc
+        openRes));
+    Panels[1 - LastFocusedPanel].Enable(true);
+    Panels[1 - LastFocusedPanel].Show(SW_SHOWNORMAL);
+  }
+  else
+  {
+    NumPanels--;
+    Panels[1 - LastFocusedPanel].Enable(false);
+    Panels[1 - LastFocusedPanel].Show(SW_HIDE);
+  }
+  MoveSubWindows();
+  return S_OK;
+}
+
+void CApp::Save()
+{
+  AppState.Save();
+  CListMode listMode;
+  
+  for (unsigned i = 0; i < kNumPanelsMax; i++)
+  {
+    const CPanel &panel = Panels[i];
+    UString path;
+    if (panel._parentFolders.IsEmpty())
+      path = panel._currentFolderPrefix;
+    else
+      path = panel._parentFolders[0].ParentFolderPath;
+      // GetFolderPath(panel._parentFolders[0].ParentFolder);
+    SavePanelPath(i, path);
+    listMode.Panels[i] = panel.GetListViewMode();
+    SaveFlatView(i, panel._flatModeForArc);
+  }
+  
+  listMode.Save();
+  // Save_ShowDeleted(ShowDeletedFiles);
+}
+
+void CApp::Release()
+{
+  // It's for unloading COM dll's: don't change it.
+  for (unsigned i = 0; i < kNumPanelsMax; i++)
+    Panels[i].Release();
+}
+
+// reduces path to part that exists on disk (or root prefix of path)
+// output path is normalized (with WCHAR_PATH_SEPARATOR)
+static void Reduce_Path_To_RealFileSystemPath(UString &path)
+{
+  unsigned prefixSize = GetRootPrefixSize(path);
+
+  while (!path.IsEmpty())
+  {
+    if (NFind::DoesDirExist_FollowLink(us2fs(path)))
+    {
+      NName::NormalizeDirPathPrefix(path);
+      break;
+    }
+    int pos = path.ReverseFind_PathSepar();
+    if (pos < 0)
+    {
+      path.Empty();
+      break;
+    }
+    path.DeleteFrom((unsigned)(pos + 1));
+    if ((unsigned)pos + 1 == prefixSize)
+      break;
+    path.DeleteFrom((unsigned)pos);
+  }
+}
+
+// returns: true, if such dir exists or is root
+/*
+static bool CheckFolderPath(const UString &path)
+{
+  UString pathReduced = path;
+  Reduce_Path_To_RealFileSystemPath(pathReduced);
+  return (pathReduced == path);
+}
+*/
+
+extern UString ConvertSizeToString(UInt64 value);
+
+static void AddSizeValue(UString &s, UInt64 size)
+{
+  s += MyFormatNew(IDS_FILE_SIZE, ConvertSizeToString(size));
+}
+
+static void AddValuePair1(UString &s, UINT resourceID, UInt64 size)
+{
+  AddLangString(s, resourceID);
+  s += ": ";
+  AddSizeValue(s, size);
+  s.Add_LF();
+}
+
+void AddValuePair2(UString &s, UINT resourceID, UInt64 num, UInt64 size);
+void AddValuePair2(UString &s, UINT resourceID, UInt64 num, UInt64 size)
+{
+  if (num == 0)
+    return;
+  AddLangString(s, resourceID);
+  s += ": ";
+  s += ConvertSizeToString(num);
+
+  if (size != (UInt64)(Int64)-1)
+  {
+    s += "    ( ";
+    AddSizeValue(s, size);
+    s += " )";
+  }
+  s.Add_LF();
+}
+
+static void AddPropValueToSum(IFolderFolder *folder, int index, PROPID propID, UInt64 &sum)
+{
+  if (sum == (UInt64)(Int64)-1)
+    return;
+  NCOM::CPropVariant prop;
+  folder->GetProperty(index, propID, &prop);
+  UInt64 val = 0;
+  if (ConvertPropVariantToUInt64(prop, val))
+    sum += val;
+  else
+    sum = (UInt64)(Int64)-1;
+}
+
+UString CPanel::GetItemsInfoString(const CRecordVector<UInt32> &indices)
+{
+  UString info;
+  UInt64 numDirs, numFiles, filesSize, foldersSize;
+  numDirs = numFiles = filesSize = foldersSize = 0;
+  
+  unsigned i;
+  for (i = 0; i < indices.Size(); i++)
+  {
+    int index = indices[i];
+    if (IsItem_Folder(index))
+    {
+      AddPropValueToSum(_folder, index, kpidSize, foldersSize);
+      numDirs++;
+    }
+    else
+    {
+      AddPropValueToSum(_folder, index, kpidSize, filesSize);
+      numFiles++;
+    }
+  }
+
+  AddValuePair2(info, IDS_PROP_FOLDERS, numDirs, foldersSize);
+  AddValuePair2(info, IDS_PROP_FILES, numFiles, filesSize);
+  int numDefined = ((foldersSize != (UInt64)(Int64)-1) && foldersSize != 0) ? 1: 0;
+  numDefined += ((filesSize != (UInt64)(Int64)-1) && filesSize != 0) ? 1: 0;
+  if (numDefined == 2)
+    AddValuePair1(info, IDS_PROP_SIZE, filesSize + foldersSize);
+  
+  info.Add_LF();
+  info += _currentFolderPrefix;
+  
+  for (i = 0; i < indices.Size() && (int)i < (int)kCopyDialog_NumInfoLines - 6; i++)
+  {
+    info.Add_LF();
+    info += "  ";
+    int index = indices[i];
+    info += GetItemRelPath(index);
+    if (IsItem_Folder(index))
+      info.Add_PathSepar();
+  }
+  if (i != indices.Size())
+  {
+    info.Add_LF();
+    info += "  ...";
+  }
+  return info;
+}
+
+bool IsCorrectFsName(const UString &name);
+
+
+
+/* Returns true, if path is path that can be used as path for File System functions
+*/
+
+/*
+static bool IsFsPath(const FString &path)
+{
+  if (!IsAbsolutePath(path))
+    return false;
+  unsigned prefixSize = GetRootPrefixSize(path);
+}
+*/
+
+void CApp::OnCopy(bool move, bool copyToSame, int srcPanelIndex)
+{
+  unsigned destPanelIndex = (NumPanels <= 1) ? srcPanelIndex : (1 - srcPanelIndex);
+  CPanel &srcPanel = Panels[srcPanelIndex];
+  CPanel &destPanel = Panels[destPanelIndex];
+
+  CPanel::CDisableTimerProcessing disableTimerProcessing1(destPanel);
+  CPanel::CDisableTimerProcessing disableTimerProcessing2(srcPanel);
+
+  if (move)
+  {
+    if (!srcPanel.CheckBeforeUpdate(IDS_MOVE))
+      return;
+  }
+  else if (!srcPanel.DoesItSupportOperations())
+  {
+    srcPanel.MessageBox_Error_UnsupportOperation();
+    return;
+  }
+
+  CRecordVector<UInt32> indices;
+  UString destPath;
+  bool useDestPanel = false;
+
+  {
+    if (copyToSame)
+    {
+      int focusedItem = srcPanel._listView.GetFocusedItem();
+      if (focusedItem < 0)
+        return;
+      int realIndex = srcPanel.GetRealItemIndex(focusedItem);
+      if (realIndex == kParentIndex)
+        return;
+      indices.Add(realIndex);
+      destPath = srcPanel.GetItemName(realIndex);
+    }
+    else
+    {
+      srcPanel.GetOperatedIndicesSmart(indices);
+      if (indices.Size() == 0)
+        return;
+      destPath = destPanel.GetFsPath();
+      if (NumPanels == 1)
+        Reduce_Path_To_RealFileSystemPath(destPath);
+    }
+  }
+  
+  UStringVector copyFolders;
+  ReadCopyHistory(copyFolders);
+  
+  bool useFullItemPaths = srcPanel.Is_IO_FS_Folder(); // maybe we need flat also here ??
+
+  {
+    CCopyDialog copyDialog;
+
+    copyDialog.Strings = copyFolders;
+    copyDialog.Value = destPath;
+    LangString(move ? IDS_MOVE : IDS_COPY, copyDialog.Title);
+    LangString(move ? IDS_MOVE_TO : IDS_COPY_TO, copyDialog.Static);
+    copyDialog.Info = srcPanel.GetItemsInfoString(indices);
+
+    if (copyDialog.Create(srcPanel.GetParent()) != IDOK)
+      return;
+
+    destPath = copyDialog.Value;
+  }
+
+  {
+    if (destPath.IsEmpty())
+    {
+      srcPanel.MessageBox_Error_UnsupportOperation();
+      return;
+    }
+
+    UString correctName;
+    if (!srcPanel.CorrectFsPath(destPath, correctName))
+    {
+      srcPanel.MessageBox_Error_HRESULT(E_INVALIDARG);
+      return;
+    }
+
+    if (IsAbsolutePath(destPath))
+      destPath.Empty();
+    else
+      destPath = srcPanel.GetFsPath();
+    destPath += correctName;
+
+    #if defined(_WIN32) && !defined(UNDER_CE)
+    if (destPath.Len() > 0 && destPath[0] == '\\')
+      if (destPath.Len() == 1 || destPath[1] != '\\')
+      {
+        srcPanel.MessageBox_Error_UnsupportOperation();
+        return;
+      }
+    #endif
+
+    bool possibleToUseDestPanel = false;
+
+    if (CompareFileNames(destPath, destPanel.GetFsPath()) == 0)
+    {
+      if (NumPanels == 1 || CompareFileNames(destPath, srcPanel.GetFsPath()) == 0)
+      {
+        srcPanel.MessageBox_Error(L"Cannot copy files onto itself");
+        return;
+      }
+
+      if (destPanel.DoesItSupportOperations())
+        possibleToUseDestPanel = true;
+    }
+
+    bool destIsFsPath = false;
+
+    if (possibleToUseDestPanel)
+    {
+      if (destPanel.IsFSFolder() || destPanel.IsAltStreamsFolder())
+        destIsFsPath = true;
+      else if (destPanel.IsFSDrivesFolder() || destPanel.IsRootFolder())
+      {
+        srcPanel.MessageBox_Error_UnsupportOperation();
+        return;
+      }
+    }
+    else
+    {
+      if (IsAltPathPrefix(us2fs(destPath)))
+      {
+        // we allow alt streams dest only to alt stream folder in second panel
+        srcPanel.MessageBox_Error_UnsupportOperation();
+        return;
+        /*
+        FString basePath = us2fs(destPath);
+        basePath.DeleteBack();
+        if (!DoesFileOrDirExist(basePath))
+        {
+          srcPanel.MessageBoxError2Lines(basePath, ERROR_FILE_NOT_FOUND); // GetLastError()
+          return;
+        }
+        destIsFsPath = true;
+        */
+      }
+      else
+      {
+        if (indices.Size() == 1 &&
+          !destPath.IsEmpty() && !IS_PATH_SEPAR(destPath.Back()))
+        {
+          int pos = destPath.ReverseFind_PathSepar();
+          if (pos < 0)
+          {
+            srcPanel.MessageBox_Error_UnsupportOperation();
+            return;
+          }
+          {
+            /*
+            #ifdef _WIN32
+            UString name = destPath.Ptr(pos + 1);
+            if (name.Find(L':') >= 0)
+            {
+              srcPanel.MessageBox_Error_UnsupportOperation();
+              return;
+            }
+            #endif
+            */
+            UString prefix = destPath.Left(pos + 1);
+            if (!CreateComplexDir(us2fs(prefix)))
+            {
+              DWORD lastError = ::GetLastError();
+              srcPanel.MessageBox_Error_2Lines_Message_HRESULT(prefix, lastError);
+              return;
+            }
+          }
+          // bool isFolder = srcPanael.IsItem_Folder(indices[0]);
+        }
+        else
+        {
+          NName::NormalizeDirPathPrefix(destPath);
+          if (!CreateComplexDir(us2fs(destPath)))
+          {
+            DWORD lastError = ::GetLastError();
+            srcPanel.MessageBox_Error_2Lines_Message_HRESULT(destPath, lastError);
+            return;
+          }
+        }
+        destIsFsPath = true;
+      }
+    }
+
+    if (!destIsFsPath)
+      useDestPanel = true;
+
+    AddUniqueStringToHeadOfList(copyFolders, destPath);
+    while (copyFolders.Size() > 20)
+      copyFolders.DeleteBack();
+    SaveCopyHistory(copyFolders);
+  }
+
+  bool useSrcPanel = !useDestPanel || !srcPanel.Is_IO_FS_Folder();
+
+  bool useTemp = useSrcPanel && useDestPanel;
+  if (useTemp && NumPanels == 1)
+  {
+    srcPanel.MessageBox_Error_UnsupportOperation();
+    return;
+  }
+  
+  CTempDir tempDirectory;
+  FString tempDirPrefix;
+  if (useTemp)
+  {
+    tempDirectory.Create(kTempDirPrefix);
+    tempDirPrefix = tempDirectory.GetPath();
+    NFile::NName::NormalizeDirPathPrefix(tempDirPrefix);
+  }
+
+  CSelectedState srcSelState;
+  CSelectedState destSelState;
+  srcPanel.SaveSelectedState(srcSelState);
+  destPanel.SaveSelectedState(destSelState);
+
+  CPanel::CDisableNotify disableNotify1(destPanel);
+  CPanel::CDisableNotify disableNotify2(srcPanel);
+
+  HRESULT result = S_OK;
+  
+  if (useSrcPanel)
+  {
+    CCopyToOptions options;
+    options.folder = useTemp ? fs2us(tempDirPrefix) : destPath;
+    options.moveMode = move;
+    options.includeAltStreams = true;
+    options.replaceAltStreamChars = false;
+    options.showErrorMessages = true;
+
+    result = srcPanel.CopyTo(options, indices, NULL);
+  }
+  
+  if (result == S_OK && useDestPanel)
+  {
+    UStringVector filePaths;
+    UString folderPrefix;
+    
+    if (useTemp)
+      folderPrefix = fs2us(tempDirPrefix);
+    else
+      folderPrefix = srcPanel.GetFsPath();
+    
+    filePaths.ClearAndReserve(indices.Size());
+    
+    FOR_VECTOR (i, indices)
+    {
+      UInt32 index = indices[i];
+      UString s;
+      if (useFullItemPaths)
+        s = srcPanel.GetItemRelPath2(index);
+      else
+        s = srcPanel.GetItemName_for_Copy(index);
+      filePaths.AddInReserved(s);
+    }
+    
+    result = destPanel.CopyFrom(move, folderPrefix, filePaths, true, 0);
+  }
+  
+  if (result != S_OK)
+  {
+    // disableNotify1.Restore();
+    // disableNotify2.Restore();
+    // For Password:
+    // srcPanel.SetFocusToList();
+    // srcPanel.InvalidateList(NULL, true);
+
+    if (result != E_ABORT)
+      srcPanel.MessageBox_Error_HRESULT(result);
+    // return;
+  }
+
+  RefreshTitleAlways();
+  
+  if (copyToSame || move)
+  {
+    srcPanel.RefreshListCtrl(srcSelState);
+  }
+  
+  if (!copyToSame)
+  {
+    destPanel.RefreshListCtrl(destSelState);
+    srcPanel.KillSelection();
+  }
+
+  disableNotify1.Restore();
+  disableNotify2.Restore();
+  srcPanel.SetFocusToList();
+}
+
+void CApp::OnSetSameFolder(int srcPanelIndex)
+{
+  if (NumPanels <= 1)
+    return;
+  const CPanel &srcPanel = Panels[srcPanelIndex];
+  CPanel &destPanel = Panels[1 - srcPanelIndex];
+  destPanel.BindToPathAndRefresh(srcPanel._currentFolderPrefix);
+}
+
+void CApp::OnSetSubFolder(int srcPanelIndex)
+{
+  if (NumPanels <= 1)
+    return;
+  const CPanel &srcPanel = Panels[srcPanelIndex];
+  CPanel &destPanel = Panels[1 - srcPanelIndex];
+
+  int focusedItem = srcPanel._listView.GetFocusedItem();
+  if (focusedItem < 0)
+    return;
+  int realIndex = srcPanel.GetRealItemIndex(focusedItem);
+  if (!srcPanel.IsItem_Folder(realIndex))
+    return;
+
+  // destPanel.BindToFolder(srcPanel._currentFolderPrefix + srcPanel.GetItemName(realIndex) + WCHAR_PATH_SEPARATOR);
+
+  CMyComPtr<IFolderFolder> newFolder;
+  if (realIndex == kParentIndex)
+  {
+    if (srcPanel._folder->BindToParentFolder(&newFolder) != S_OK)
+      return;
+    if (!newFolder)
+    {
+      {
+        const UString parentPrefix = srcPanel.GetParentDirPrefix();
+        COpenResult openRes;
+        destPanel.BindToPath(parentPrefix, UString(), openRes);
+      }
+      destPanel.RefreshListCtrl();
+      return;
+    }
+  }
+  else
+  {
+    if (srcPanel._folder->BindToFolder(realIndex, &newFolder) != S_OK)
+      return;
+  }
+
+  if (!newFolder)
+    return;
+
+  destPanel.CloseOpenFolders();
+  destPanel.SetNewFolder(newFolder);
+  destPanel.RefreshListCtrl();
+}
+
+/*
+int CApp::GetFocusedPanelIndex() const
+{
+  return LastFocusedPanel;
+  HWND hwnd = ::GetFocus();
+  for (;;)
+  {
+    if (hwnd == 0)
+      return 0;
+    for (unsigned i = 0; i < kNumPanelsMax; i++)
+    {
+      if (PanelsCreated[i] &&
+          ((HWND)Panels[i] == hwnd || Panels[i]._listView == hwnd))
+        return i;
+    }
+    hwnd = GetParent(hwnd);
+  }
+}
+*/
+
+static UString g_ToolTipBuffer;
+static CSysString g_ToolTipBufferSys;
+
+void CApp::OnNotify(int /* ctrlID */, LPNMHDR pnmh)
+{
+  {
+    if (pnmh->code == TTN_GETDISPINFO)
+    {
+      LPNMTTDISPINFO info = (LPNMTTDISPINFO)pnmh;
+      info->hinst = 0;
+      g_ToolTipBuffer.Empty();
+      SetButtonText((int)info->hdr.idFrom, g_ToolTipBuffer);
+      g_ToolTipBufferSys = GetSystemString(g_ToolTipBuffer);
+      info->lpszText = g_ToolTipBufferSys.Ptr_non_const();
+      return;
+    }
+    #ifndef _UNICODE
+    if (pnmh->code == TTN_GETDISPINFOW)
+    {
+      LPNMTTDISPINFOW info = (LPNMTTDISPINFOW)pnmh;
+      info->hinst = 0;
+      g_ToolTipBuffer.Empty();
+      SetButtonText((int)info->hdr.idFrom, g_ToolTipBuffer);
+      info->lpszText = g_ToolTipBuffer.Ptr_non_const();
+      return;
+    }
+    #endif
+  }
+}
+
+void CApp::RefreshTitle(bool always)
+{
+  UString path = GetFocusedPanel()._currentFolderPrefix;
+  if (path.IsEmpty())
+    path = "7-Zip"; // LangString(IDS_APP_TITLE);
+  if (!always && path == PrevTitle)
+    return;
+  PrevTitle = path;
+  NWindows::MySetWindowText(_window, path);
+}
+
+void CApp::RefreshTitlePanel(unsigned panelIndex, bool always)
+{
+  if (panelIndex != GetFocusedPanelIndex())
+    return;
+  RefreshTitle(always);
+}
+
+static void AddUniqueStringToHead(UStringVector &list, const UString &s)
+{
+  for (unsigned i = 0; i < list.Size();)
+    if (s.IsEqualTo_NoCase(list[i]))
+      list.Delete(i);
+    else
+      i++;
+  list.Insert(0, s);
+}
+
+
+void CFolderHistory::Normalize()
+{
+  const unsigned kMaxSize = 100;
+  if (Strings.Size() > kMaxSize)
+    Strings.DeleteFrom(kMaxSize);
+}
+
+void CFolderHistory::AddString(const UString &s)
+{
+  NSynchronization::CCriticalSectionLock lock(_criticalSection);
+  AddUniqueStringToHead(Strings, s);
+  Normalize();
+}
diff --git a/CPP/7zip/UI/FileManager/App.h b/CPP/7zip/UI/FileManager/App.h
new file mode 100644
index 0000000..3c3c5ef
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/App.h
@@ -0,0 +1,378 @@
+// App.h
+
+#ifndef __APP_H
+#define __APP_H
+
+#include "../../../Windows/Control/CommandBar.h"
+#include "../../../Windows/Control/ImageList.h"
+
+#include "AppState.h"
+#include "Panel.h"
+
+class CApp;
+
+extern CApp g_App;
+extern HWND g_HWND;
+
+const unsigned kNumPanelsMax = 2;
+
+extern bool g_IsSmallScreen;
+
+// must be larger than context menu IDs
+const int kMenuCmdID_Toolbar_Start = 1070;
+const int kMenuCmdID_Plugin_Start = 1100;
+
+enum
+{
+  kMenuCmdID_Toolbar_Add = kMenuCmdID_Toolbar_Start,
+  kMenuCmdID_Toolbar_Extract,
+  kMenuCmdID_Toolbar_Test,
+  kMenuCmdID_Toolbar_End
+};
+
+class CPanelCallbackImp: public CPanelCallback
+{
+  CApp *_app;
+  unsigned _index;
+public:
+  void Init(CApp *app, unsigned index)
+  {
+    _app = app;
+    _index = index;
+  }
+  virtual void OnTab();
+  virtual void SetFocusToPath(unsigned index);
+  virtual void OnCopy(bool move, bool copyToSame);
+  virtual void OnSetSameFolder();
+  virtual void OnSetSubFolder();
+  virtual void PanelWasFocused();
+  virtual void DragBegin();
+  virtual void DragEnd();
+  virtual void RefreshTitle(bool always);
+};
+
+class CApp;
+
+class CDropTarget:
+  public IDropTarget,
+  public CMyUnknownImp
+{
+  CMyComPtr<IDataObject> m_DataObject;
+  UStringVector m_SourcePaths;
+  int m_SelectionIndex;
+  bool m_DropIsAllowed;      // = true, if data contain fillist
+  bool m_PanelDropIsAllowed; // = false, if current target_panel is source_panel.
+                             // check it only if m_DropIsAllowed == true
+  int m_SubFolderIndex;
+  UString m_SubFolderName;
+
+  CPanel *m_Panel;
+  bool m_IsAppTarget;        // true, if we want to drop to app window (not to panel).
+
+  bool m_SetPathIsOK;
+
+  bool IsItSameDrive() const;
+
+  void QueryGetData(IDataObject *dataObject);
+  bool IsFsFolderPath() const;
+  DWORD GetEffect(DWORD keyState, POINTL pt, DWORD allowedEffect);
+  void RemoveSelection();
+  void PositionCursor(POINTL ptl);
+  UString GetTargetPath() const;
+  bool SetPath(bool enablePath) const;
+  bool SetPath();
+
+public:
+  MY_UNKNOWN_IMP1_MT(IDropTarget)
+  STDMETHOD(DragEnter)(IDataObject * dataObject, DWORD keyState, POINTL pt, DWORD *effect);
+  STDMETHOD(DragOver)(DWORD keyState, POINTL pt, DWORD * effect);
+  STDMETHOD(DragLeave)();
+  STDMETHOD(Drop)(IDataObject * dataObject, DWORD keyState, POINTL pt, DWORD *effect);
+
+  CDropTarget():
+      m_SelectionIndex(-1),
+      m_DropIsAllowed(false),
+      m_PanelDropIsAllowed(false),
+      m_SubFolderIndex(-1),
+      m_Panel(NULL),
+      m_IsAppTarget(false),
+      m_SetPathIsOK(false),
+      App(NULL),
+      SrcPanelIndex(-1),
+      TargetPanelIndex(-1)
+      {}
+
+  CApp *App;
+  int SrcPanelIndex;              // index of D&D source_panel
+  int TargetPanelIndex;           // what panel to use as target_panel of Application
+};
+
+
+class CApp
+{
+public:
+  NWindows::CWindow _window;
+  bool ShowSystemMenu;
+  // bool ShowDeletedFiles;
+  unsigned NumPanels;
+  unsigned LastFocusedPanel;
+
+  bool ShowStandardToolbar;
+  bool ShowArchiveToolbar;
+  bool ShowButtonsLables;
+  bool LargeButtons;
+
+  CAppState AppState;
+  CPanelCallbackImp m_PanelCallbackImp[kNumPanelsMax];
+  CPanel Panels[kNumPanelsMax];
+
+  NWindows::NControl::CImageList _buttonsImageList;
+
+  #ifdef UNDER_CE
+  NWindows::NControl::CCommandBar _commandBar;
+  #endif
+  NWindows::NControl::CToolBar _toolBar;
+
+  CDropTarget *_dropTargetSpec;
+  CMyComPtr<IDropTarget> _dropTarget;
+
+  UString LangString_N_SELECTED_ITEMS;
+  
+  void ReloadLang();
+
+  CApp(): _window(0), NumPanels(2), LastFocusedPanel(0),
+    AutoRefresh_Mode(true)
+  {
+    SetPanels_AutoRefresh_Mode();
+  }
+
+  void CreateDragTarget()
+  {
+    _dropTargetSpec = new CDropTarget();
+    _dropTarget = _dropTargetSpec;
+    _dropTargetSpec->App = (this);
+  }
+
+  void SetFocusedPanel(unsigned index)
+  {
+    LastFocusedPanel = index;
+    _dropTargetSpec->TargetPanelIndex = LastFocusedPanel;
+  }
+
+  void DragBegin(unsigned panelIndex)
+  {
+    _dropTargetSpec->TargetPanelIndex = (NumPanels > 1) ? 1 - panelIndex : panelIndex;
+    _dropTargetSpec->SrcPanelIndex = panelIndex;
+  }
+
+  void DragEnd()
+  {
+    _dropTargetSpec->TargetPanelIndex = LastFocusedPanel;
+    _dropTargetSpec->SrcPanelIndex = -1;
+  }
+
+  
+  void OnCopy(bool move, bool copyToSame, int srcPanelIndex);
+  void OnSetSameFolder(int srcPanelIndex);
+  void OnSetSubFolder(int srcPanelIndex);
+
+  HRESULT CreateOnePanel(int panelIndex, const UString &mainPath, const UString &arcFormat, bool needOpenArc, COpenResult &openRes);
+  HRESULT Create(HWND hwnd, const UString &mainPath, const UString &arcFormat, int xSizes[2], bool needOpenArc, COpenResult &openRes);
+  void Read();
+  void Save();
+  void Release();
+
+  // void SetFocus(int panelIndex) { Panels[panelIndex].SetFocusToList(); }
+  void SetFocusToLastItem() { Panels[LastFocusedPanel].SetFocusToLastRememberedItem(); }
+  unsigned GetFocusedPanelIndex() const { return LastFocusedPanel; }
+  bool IsPanelVisible(unsigned index) const { return (NumPanels > 1 || index == LastFocusedPanel); }
+  CPanel &GetFocusedPanel() { return Panels[GetFocusedPanelIndex()]; }
+
+  // File Menu
+  void OpenItem() { GetFocusedPanel().OpenSelectedItems(true); }
+  void OpenItemInside(const wchar_t *type) { GetFocusedPanel().OpenFocusedItemAsInternal(type); }
+  void OpenItemOutside() { GetFocusedPanel().OpenSelectedItems(false); }
+  void EditItem(bool useEditor) { GetFocusedPanel().EditItem(useEditor); }
+  void Rename() { GetFocusedPanel().RenameFile(); }
+  void CopyTo() { OnCopy(false, false, GetFocusedPanelIndex()); }
+  void MoveTo() { OnCopy(true, false, GetFocusedPanelIndex()); }
+  void Delete(bool toRecycleBin) { GetFocusedPanel().DeleteItems(toRecycleBin); }
+  HRESULT CalculateCrc2(const UString &methodName);
+  void CalculateCrc(const char *methodName);
+
+  void DiffFiles(const UString &path1, const UString &path2);
+  void DiffFiles();
+  
+  void VerCtrl(unsigned id);
+
+  void Split();
+  void Combine();
+  void Properties() { GetFocusedPanel().Properties(); }
+  void Comment() { GetFocusedPanel().ChangeComment(); }
+  
+  #ifndef UNDER_CE
+  void Link();
+  void OpenAltStreams() { GetFocusedPanel().OpenAltStreams(); }
+  #endif
+
+  void CreateFolder() { GetFocusedPanel().CreateFolder(); }
+  void CreateFile() { GetFocusedPanel().CreateFile(); }
+
+  // Edit
+  void EditCut() { GetFocusedPanel().EditCut(); }
+  void EditCopy() { GetFocusedPanel().EditCopy(); }
+  void EditPaste() { GetFocusedPanel().EditPaste(); }
+
+  void SelectAll(bool selectMode) { GetFocusedPanel().SelectAll(selectMode); }
+  void InvertSelection() { GetFocusedPanel().InvertSelection(); }
+  void SelectSpec(bool selectMode) { GetFocusedPanel().SelectSpec(selectMode); }
+  void SelectByType(bool selectMode) { GetFocusedPanel().SelectByType(selectMode); }
+
+  void Refresh_StatusBar() { GetFocusedPanel().Refresh_StatusBar(); }
+
+  void SetListViewMode(UInt32 index) { GetFocusedPanel().SetListViewMode(index); }
+  UInt32 GetListViewMode() { return GetFocusedPanel().GetListViewMode(); }
+  PROPID GetSortID() { return GetFocusedPanel().GetSortID(); }
+
+  void SortItemsWithPropID(PROPID propID) { GetFocusedPanel().SortItemsWithPropID(propID); }
+
+  void OpenRootFolder() { GetFocusedPanel().OpenDrivesFolder(); }
+  void OpenParentFolder() { GetFocusedPanel().OpenParentFolder(); }
+  void FoldersHistory() { GetFocusedPanel().FoldersHistory(); }
+  void RefreshView() { GetFocusedPanel().OnReload(); }
+  void RefreshAllPanels()
+  {
+    for (unsigned i = 0; i < NumPanels; i++)
+    {
+      unsigned index = i;
+      if (NumPanels == 1)
+        index = LastFocusedPanel;
+      Panels[index].OnReload();
+    }
+  }
+
+  /*
+  void SysIconsWereChanged()
+  {
+    for (unsigned i = 0; i < NumPanels; i++)
+    {
+      unsigned index = i;
+      if (NumPanels == 1)
+        index = LastFocusedPanel;
+      Panels[index].SysIconsWereChanged();
+    }
+  }
+  */
+
+  void SetListSettings();
+  HRESULT SwitchOnOffOnePanel();
+  
+  CIntVector _timestampLevels;
+
+  bool GetFlatMode() { return Panels[LastFocusedPanel].GetFlatMode(); }
+
+  int GetTimestampLevel() const { return Panels[LastFocusedPanel]._timestampLevel; }
+  void SetTimestampLevel(int level)
+  {
+    unsigned i;
+    for (i = 0; i < kNumPanelsMax; i++)
+    {
+      CPanel &panel = Panels[i];
+      panel._timestampLevel = level;
+      if (panel.PanelCreated)
+        panel.RedrawListItems();
+    }
+  }
+
+  // bool Get_ShowNtfsStrems_Mode() { return Panels[LastFocusedPanel].Get_ShowNtfsStrems_Mode(); }
+  
+  void ChangeFlatMode() { Panels[LastFocusedPanel].ChangeFlatMode(); }
+  // void Change_ShowNtfsStrems_Mode() { Panels[LastFocusedPanel].Change_ShowNtfsStrems_Mode(); }
+  // void Change_ShowDeleted() { ShowDeletedFiles = !ShowDeletedFiles; }
+
+  bool AutoRefresh_Mode;
+  bool Get_AutoRefresh_Mode()
+  {
+    // return Panels[LastFocusedPanel].Get_ShowNtfsStrems_Mode();
+    return AutoRefresh_Mode;
+  }
+  void Change_AutoRefresh_Mode()
+  {
+    AutoRefresh_Mode = !AutoRefresh_Mode;
+    SetPanels_AutoRefresh_Mode();
+  }
+  void SetPanels_AutoRefresh_Mode()
+  {
+    for (unsigned i = 0; i < kNumPanelsMax; i++)
+      Panels[i].Set_AutoRefresh_Mode(AutoRefresh_Mode);
+  }
+
+  void OpenBookmark(int index) { GetFocusedPanel().OpenBookmark(index); }
+  void SetBookmark(int index) { GetFocusedPanel().SetBookmark(index); }
+
+  void ReloadToolbars();
+  void ReadToolbar()
+  {
+    UInt32 mask = ReadToolbarsMask();
+    if (mask & ((UInt32)1 << 31))
+    {
+      ShowButtonsLables = !g_IsSmallScreen;
+      LargeButtons = false;
+      ShowStandardToolbar = ShowArchiveToolbar = true;
+    }
+    else
+    {
+      ShowButtonsLables = ((mask & 1) != 0);
+      LargeButtons = ((mask & 2) != 0);
+      ShowStandardToolbar = ((mask & 4) != 0);
+      ShowArchiveToolbar  = ((mask & 8) != 0);
+    }
+  }
+  void SaveToolbar()
+  {
+    UInt32 mask = 0;
+    if (ShowButtonsLables) mask |= 1;
+    if (LargeButtons) mask |= 2;
+    if (ShowStandardToolbar) mask |= 4;
+    if (ShowArchiveToolbar) mask |= 8;
+    SaveToolbarsMask(mask);
+  }
+  
+  void SaveToolbarChanges();
+
+  void SwitchStandardToolbar()
+  {
+    ShowStandardToolbar = !ShowStandardToolbar;
+    SaveToolbarChanges();
+  }
+  void SwitchArchiveToolbar()
+  {
+    ShowArchiveToolbar = !ShowArchiveToolbar;
+    SaveToolbarChanges();
+  }
+  void SwitchButtonsLables()
+  {
+    ShowButtonsLables = !ShowButtonsLables;
+    SaveToolbarChanges();
+  }
+  void SwitchLargeButtons()
+  {
+    LargeButtons = !LargeButtons;
+    SaveToolbarChanges();
+  }
+
+  void AddToArchive() { GetFocusedPanel().AddToArchive(); }
+  void ExtractArchives() { GetFocusedPanel().ExtractArchives(); }
+  void TestArchives() { GetFocusedPanel().TestArchives(); }
+
+  void OnNotify(int ctrlID, LPNMHDR pnmh);
+
+  UString PrevTitle;
+  void RefreshTitle(bool always = false);
+  void RefreshTitleAlways() { RefreshTitle(true); }
+  void RefreshTitlePanel(unsigned panelIndex, bool always = false);
+
+  void MoveSubWindows();
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/AppState.h b/CPP/7zip/UI/FileManager/AppState.h
new file mode 100644
index 0000000..cc88715
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/AppState.h
@@ -0,0 +1,95 @@
+// AppState.h
+
+#ifndef __APP_STATE_H
+#define __APP_STATE_H
+
+#include "../../../Windows/Synchronization.h"
+
+#include "ViewSettings.h"
+
+class CFastFolders
+{
+  NWindows::NSynchronization::CCriticalSection _criticalSection;
+public:
+  UStringVector Strings;
+  void SetString(unsigned index, const UString &s)
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+    while (Strings.Size() <= index)
+      Strings.AddNew();
+    Strings[index] = s;
+  }
+  UString GetString(unsigned index)
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+    if (index >= Strings.Size())
+      return UString();
+    return Strings[index];
+  }
+  void Save()
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+    SaveFastFolders(Strings);
+  }
+  void Read()
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+    ReadFastFolders(Strings);
+  }
+};
+
+class CFolderHistory
+{
+  NWindows::NSynchronization::CCriticalSection _criticalSection;
+  UStringVector Strings;
+
+  void Normalize();
+  
+public:
+  
+  void GetList(UStringVector &foldersHistory)
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+    foldersHistory = Strings;
+  }
+  
+  void AddString(const UString &s);
+
+  void RemoveAll()
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+    Strings.Clear();
+  }
+  
+  void Save()
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+    SaveFolderHistory(Strings);
+  }
+  
+  void Read()
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+    ReadFolderHistory(Strings);
+    Normalize();
+  }
+};
+
+struct CAppState
+{
+  CFastFolders FastFolders;
+  CFolderHistory FolderHistory;
+
+  void Save()
+  {
+    FastFolders.Save();
+    FolderHistory.Save();
+  }
+  void Read()
+  {
+    FastFolders.Read();
+    FolderHistory.Read();
+  }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/BrowseDialog.cpp b/CPP/7zip/UI/FileManager/BrowseDialog.cpp
new file mode 100644
index 0000000..6d2b6b5
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/BrowseDialog.cpp
@@ -0,0 +1,1025 @@
+// BrowseDialog.cpp
+ 
+#include "StdAfx.h"
+
+#include "../../../Common/MyWindows.h"
+
+#include <CommCtrl.h>
+
+#ifndef UNDER_CE
+#include "../../../Windows/CommonDialog.h"
+#include "../../../Windows/Shell.h"
+#endif
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/FileFind.h"
+
+#ifdef UNDER_CE
+#include <commdlg.h>
+#endif
+
+#include "BrowseDialog.h"
+
+#define USE_MY_BROWSE_DIALOG
+
+#ifdef USE_MY_BROWSE_DIALOG
+
+#include "../../../Common/Defs.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#include "../../../Windows/Control/ComboBox.h"
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/Edit.h"
+#include "../../../Windows/Control/ListView.h"
+
+#include "BrowseDialogRes.h"
+#include "PropertyNameRes.h"
+#include "SysIconUtils.h"
+
+#ifndef _SFX
+#include "RegistryUtils.h"
+#endif
+
+#endif
+
+#include "ComboDialog.h"
+#include "LangUtils.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NName;
+using namespace NFind;
+
+#ifdef USE_MY_BROWSE_DIALOG
+
+extern bool g_LVN_ITEMACTIVATE_Support;
+
+static const int kParentIndex = -1;
+static const UINT k_Message_RefreshPathEdit = WM_APP + 1;
+
+static HRESULT GetNormalizedError()
+{
+  DWORD errorCode = GetLastError();
+  return errorCode == 0 ? E_FAIL : errorCode;
+}
+
+extern UString HResultToMessage(HRESULT errorCode);
+
+static void MessageBox_Error_Global(HWND wnd, const wchar_t *message)
+{
+  ::MessageBoxW(wnd, message, L"7-Zip", MB_ICONERROR);
+}
+
+static void MessageBox_HResError(HWND wnd, HRESULT errorCode, const wchar_t *name)
+{
+  UString s = HResultToMessage(errorCode);
+  if (name)
+  {
+    s.Add_LF();
+    s += name;
+  }
+  MessageBox_Error_Global(wnd, s);
+}
+
+class CBrowseDialog: public NControl::CModalDialog
+{
+  NControl::CListView _list;
+  NControl::CEdit _pathEdit;
+  NControl::CComboBox _filterCombo;
+
+  CObjectVector<CFileInfo> _files;
+
+  CExtToIconMap _extToIconMap;
+  int _sortIndex;
+  bool _ascending;
+  bool _showDots;
+  UString _topDirPrefix; // we don't open parent of that folder
+  UString DirPrefix;
+
+  virtual bool OnInit();
+  virtual bool OnSize(WPARAM wParam, int xSize, int ySize);
+  virtual bool OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
+  virtual bool OnNotify(UINT controlID, LPNMHDR header);
+  virtual bool OnKeyDown(LPNMLVKEYDOWN keyDownInfo);
+  virtual bool OnButtonClicked(int buttonID, HWND buttonHWND);
+  virtual void OnOK();
+
+  void Post_RefreshPathEdit() { PostMsg(k_Message_RefreshPathEdit); }
+
+  bool GetParentPath(const UString &path, UString &parentPrefix, UString &name);
+  // Reload changes DirPrefix. Don't send DirPrefix in pathPrefix parameter
+  HRESULT Reload(const UString &pathPrefix, const UString &selectedName);
+  HRESULT Reload();
+  
+  void OpenParentFolder();
+  void SetPathEditText();
+  void OnCreateDir();
+  void OnItemEnter();
+  void FinishOnOK();
+
+  int GetRealItemIndex(int indexInListView) const
+  {
+    LPARAM param;
+    if (!_list.GetItemParam(indexInListView, param))
+      return (int)-1;
+    return (int)param;
+  }
+
+public:
+  bool FolderMode;
+  UString Title;
+  UString FilePath;  // input/ result path
+  bool ShowAllFiles;
+  UStringVector Filters;
+  UString FilterDescription;
+
+  CBrowseDialog(): _showDots(false), FolderMode(false), ShowAllFiles(true) {}
+  void SetFilter(const UString &s);
+  INT_PTR Create(HWND parent = 0) { return CModalDialog::Create(IDD_BROWSE, parent); }
+  int CompareItems(LPARAM lParam1, LPARAM lParam2);
+};
+
+void CBrowseDialog::SetFilter(const UString &s)
+{
+  Filters.Clear();
+  UString mask;
+  unsigned i;
+  for (i = 0; i < s.Len(); i++)
+  {
+    wchar_t c = s[i];
+    if (c == ';')
+    {
+      if (!mask.IsEmpty())
+        Filters.Add(mask);
+      mask.Empty();
+    }
+    else
+      mask += c;
+  }
+  if (!mask.IsEmpty())
+    Filters.Add(mask);
+  ShowAllFiles = Filters.IsEmpty();
+  for (i = 0; i < Filters.Size(); i++)
+  {
+    const UString &f = Filters[i];
+    if (f == L"*.*" || f == L"*")
+    {
+      ShowAllFiles = true;
+      break;
+    }
+  }
+}
+
+bool CBrowseDialog::OnInit()
+{
+  #ifdef LANG
+  LangSetDlgItems(*this, NULL, 0);
+  #endif
+  if (!Title.IsEmpty())
+    SetText(Title);
+  _list.Attach(GetItem(IDL_BROWSE));
+  _filterCombo.Attach(GetItem(IDC_BROWSE_FILTER));
+  _pathEdit.Attach(GetItem(IDE_BROWSE_PATH));
+
+  if (FolderMode)
+    HideItem(IDC_BROWSE_FILTER);
+  else
+    EnableItem(IDC_BROWSE_FILTER, false);
+
+  #ifndef UNDER_CE
+  _list.SetUnicodeFormat();
+  #endif
+
+  #ifndef _SFX
+  CFmSettings st;
+  st.Load();
+  if (st.SingleClick)
+    _list.SetExtendedListViewStyle(LVS_EX_ONECLICKACTIVATE | LVS_EX_TRACKSELECT);
+  _showDots = st.ShowDots;
+  #endif
+
+  {
+    UString s;
+    if (!FilterDescription.IsEmpty())
+      s = FilterDescription;
+    else if (ShowAllFiles)
+      s = "*.*";
+    else
+    {
+      FOR_VECTOR (i, Filters)
+      {
+        if (i != 0)
+          s.Add_Space();
+        s += Filters[i];
+      }
+    }
+    _filterCombo.AddString(s);
+    _filterCombo.SetCurSel(0);
+  }
+
+  _list.SetImageList(GetSysImageList(true), LVSIL_SMALL);
+  _list.SetImageList(GetSysImageList(false), LVSIL_NORMAL);
+
+  _list.InsertColumn(0, LangString(IDS_PROP_NAME), 100);
+  _list.InsertColumn(1, LangString(IDS_PROP_MTIME), 100);
+  {
+    LV_COLUMNW column;
+    column.iSubItem = 2;
+    column.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
+    column.fmt = LVCFMT_RIGHT;
+    column.cx = 100;
+    const UString s = LangString(IDS_PROP_SIZE);
+    column.pszText = s.Ptr_non_const();
+    _list.InsertColumn(2, &column);
+  }
+
+  _list.InsertItem(0, L"12345678901234567"
+      #ifndef UNDER_CE
+      L"1234567890"
+      #endif
+      );
+  _list.SetSubItem(0, 1, L"2009-09-09"
+      #ifndef UNDER_CE
+      L" 09:09"
+      #endif
+      );
+  _list.SetSubItem(0, 2, L"9999 MB");
+  for (int i = 0; i < 3; i++)
+    _list.SetColumnWidthAuto(i);
+  _list.DeleteAllItems();
+
+  _ascending = true;
+  _sortIndex = 0;
+
+  NormalizeSize();
+
+  _topDirPrefix.Empty();
+  {
+    int rootSize = GetRootPrefixSize(FilePath);
+    #if defined(_WIN32) && !defined(UNDER_CE)
+    // We can go up from root folder to drives list
+    if (IsDrivePath(FilePath))
+      rootSize = 0;
+    else if (IsSuperPath(FilePath))
+    {
+      if (IsDrivePath(FilePath.Ptr(kSuperPathPrefixSize)))
+        rootSize = kSuperPathPrefixSize;
+    }
+    #endif
+    _topDirPrefix.SetFrom(FilePath, rootSize);
+  }
+
+  UString name;
+  if (!GetParentPath(FilePath, DirPrefix, name))
+    DirPrefix = _topDirPrefix;
+
+  for (;;)
+  {
+    UString baseFolder = DirPrefix;
+    if (Reload(baseFolder, name) == S_OK)
+      break;
+    name.Empty();
+    if (DirPrefix.IsEmpty())
+      break;
+    UString parent, name2;
+    GetParentPath(DirPrefix, parent, name2);
+    DirPrefix = parent;
+  }
+
+  if (name.IsEmpty())
+    name = FilePath;
+  if (FolderMode)
+    NormalizeDirPathPrefix(name);
+  _pathEdit.SetText(name);
+
+  #ifndef UNDER_CE
+  /* If we clear UISF_HIDEFOCUS, the focus rectangle in ListView will be visible,
+     even if we use mouse for pressing the button to open this dialog. */
+  PostMsg(MY__WM_UPDATEUISTATE, MAKEWPARAM(MY__UIS_CLEAR, MY__UISF_HIDEFOCUS));
+  #endif
+
+  return CModalDialog::OnInit();
+}
+
+bool CBrowseDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+  int mx, my;
+  {
+    RECT r;
+    GetClientRectOfItem(IDB_BROWSE_PARENT, r);
+    mx = r.left;
+    my = r.top;
+  }
+  InvalidateRect(NULL);
+
+  int xLim = xSize - mx;
+  {
+    RECT r;
+    GetClientRectOfItem(IDT_BROWSE_FOLDER, r);
+    MoveItem(IDT_BROWSE_FOLDER, r.left, r.top, xLim - r.left, RECT_SIZE_Y(r));
+  }
+
+  int bx1, bx2, by;
+  GetItemSizes(IDCANCEL, bx1, by);
+  GetItemSizes(IDOK, bx2, by);
+  int y = ySize - my - by;
+  int x = xLim - bx1;
+  MoveItem(IDCANCEL, x, y, bx1, by);
+  MoveItem(IDOK, x - mx - bx2, y, bx2, by);
+
+  // Y_Size of ComboBox is tricky. So we use Y_Size of _pathEdit instead
+
+  int yPathSize;
+  {
+    RECT r;
+    GetClientRectOfItem(IDE_BROWSE_PATH, r);
+    yPathSize = RECT_SIZE_Y(r);
+    _pathEdit.Move(r.left, y - my - yPathSize - my - yPathSize, xLim - r.left, yPathSize);
+  }
+
+  {
+    RECT r;
+    GetClientRectOfItem(IDC_BROWSE_FILTER, r);
+    _filterCombo.Move(r.left, y - my - yPathSize, xLim - r.left, RECT_SIZE_Y(r));
+  }
+
+  {
+    RECT r;
+    GetClientRectOfItem(IDL_BROWSE, r);
+    _list.Move(r.left, r.top, xLim - r.left, y - my - yPathSize - my - yPathSize - my - r.top);
+  }
+
+  return false;
+}
+
+bool CBrowseDialog::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+  if (message == k_Message_RefreshPathEdit)
+  {
+    SetPathEditText();
+    return true;
+  }
+  return CModalDialog::OnMessage(message, wParam, lParam);
+}
+
+bool CBrowseDialog::OnNotify(UINT /* controlID */, LPNMHDR header)
+{
+  if (header->hwndFrom != _list)
+    return false;
+  switch (header->code)
+  {
+    case LVN_ITEMACTIVATE:
+      if (g_LVN_ITEMACTIVATE_Support)
+        OnItemEnter();
+      break;
+    case NM_DBLCLK:
+    case NM_RETURN: // probabably it's unused
+      if (!g_LVN_ITEMACTIVATE_Support)
+        OnItemEnter();
+      break;
+    case LVN_COLUMNCLICK:
+    {
+      int index = LPNMLISTVIEW(header)->iSubItem;
+      if (index == _sortIndex)
+        _ascending = !_ascending;
+      else
+      {
+        _ascending = (index == 0);
+        _sortIndex = index;
+      }
+      Reload();
+      return false;
+    }
+    case LVN_KEYDOWN:
+    {
+      bool boolResult = OnKeyDown(LPNMLVKEYDOWN(header));
+      Post_RefreshPathEdit();
+      return boolResult;
+    }
+    case NM_RCLICK:
+    case NM_CLICK:
+    case LVN_BEGINDRAG:
+      Post_RefreshPathEdit();
+      break;
+  }
+  return false;
+}
+
+bool CBrowseDialog::OnKeyDown(LPNMLVKEYDOWN keyDownInfo)
+{
+  bool ctrl = IsKeyDown(VK_CONTROL);
+
+  switch (keyDownInfo->wVKey)
+  {
+    case VK_BACK:
+      OpenParentFolder();
+      return true;
+    case 'R':
+      if (ctrl)
+      {
+        Reload();
+        return true;
+      }
+      return false;
+    case VK_F7:
+      OnCreateDir();
+      return true;
+  }
+  return false;
+}
+
+bool CBrowseDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
+{
+  switch (buttonID)
+  {
+    case IDB_BROWSE_PARENT: OpenParentFolder(); break;
+    case IDB_BROWSE_CREATE_DIR: OnCreateDir(); break;
+    default: return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+  }
+  _list.SetFocus();
+  return true;
+}
+
+void CBrowseDialog::OnOK()
+{
+  /* When we press "Enter" in listview, Windows sends message to first Button.
+     We check that message was from ListView; */
+  if (GetFocus() == _list)
+  {
+    OnItemEnter();
+    return;
+  }
+  FinishOnOK();
+}
+
+
+bool CBrowseDialog::GetParentPath(const UString &path, UString &parentPrefix, UString &name)
+{
+  parentPrefix.Empty();
+  name.Empty();
+  if (path.IsEmpty())
+    return false;
+  if (_topDirPrefix == path)
+    return false;
+  UString s = path;
+  if (IS_PATH_SEPAR(s.Back()))
+    s.DeleteBack();
+  if (s.IsEmpty())
+    return false;
+  if (IS_PATH_SEPAR(s.Back()))
+    return false;
+  int pos = s.ReverseFind_PathSepar();
+  parentPrefix.SetFrom(s, pos + 1);
+  name = s.Ptr((unsigned)(pos + 1));
+  return true;
+}
+
+int CBrowseDialog::CompareItems(LPARAM lParam1, LPARAM lParam2)
+{
+  if (lParam1 == kParentIndex) return -1;
+  if (lParam2 == kParentIndex) return 1;
+  const CFileInfo &f1 = _files[(int)lParam1];
+  const CFileInfo &f2 = _files[(int)lParam2];
+
+  bool isDir1 = f1.IsDir();
+  bool isDir2 = f2.IsDir();
+  if (isDir1 && !isDir2) return -1;
+  if (isDir2 && !isDir1) return 1;
+  
+  int res = 0;
+  switch (_sortIndex)
+  {
+    case 0: res = CompareFileNames(fs2us(f1.Name), fs2us(f2.Name)); break;
+    case 1: res = CompareFileTime(&f1.MTime, &f2.MTime); break;
+    case 2: res = MyCompare(f1.Size, f2.Size); break;
+  }
+  return _ascending ? res: -res;
+}
+
+static int CALLBACK CompareItems2(LPARAM lParam1, LPARAM lParam2, LPARAM lpData)
+{
+  return ((CBrowseDialog *)lpData)->CompareItems(lParam1, lParam2);
+}
+
+static void ConvertSizeToString(UInt64 v, wchar_t *s)
+{
+  Byte c = 0;
+       if (v >= ((UInt64)10000 << 20)) { v >>= 30; c = 'G'; }
+  else if (v >= ((UInt64)10000 << 10)) { v >>= 20; c = 'M'; }
+  else if (v >= ((UInt64)10000 <<  0)) { v >>= 10; c = 'K'; }
+  ConvertUInt64ToString(v, s);
+  if (c != 0)
+  {
+    s += MyStringLen(s);
+    *s++ = ' ';
+    *s++ = c;
+    *s++ = 0;
+  }
+}
+
+// Reload changes DirPrefix. Don't send DirPrefix in pathPrefix parameter
+
+HRESULT CBrowseDialog::Reload(const UString &pathPrefix, const UString &selectedName)
+{
+  CObjectVector<CFileInfo> files;
+  
+  #ifndef UNDER_CE
+  bool isDrive = false;
+  if (pathPrefix.IsEmpty() || pathPrefix.IsEqualTo(kSuperPathPrefix))
+  {
+    isDrive = true;
+    FStringVector drives;
+    if (!MyGetLogicalDriveStrings(drives))
+      return GetNormalizedError();
+    FOR_VECTOR (i, drives)
+    {
+      FString d = drives[i];
+      if (d.Len() < 3 || d.Back() != '\\')
+        return E_FAIL;
+      d.DeleteBack();
+      CFileInfo &fi = files.AddNew();
+      fi.SetAsDir();
+      fi.Name = d;
+    }
+  }
+  else
+  #endif
+  {
+    CEnumerator enumerator;
+    enumerator.SetDirPrefix(us2fs(pathPrefix));
+    for (;;)
+    {
+      bool found;
+      CFileInfo fi;
+      if (!enumerator.Next(fi, found))
+        return GetNormalizedError();
+      if (!found)
+        break;
+      if (!fi.IsDir())
+      {
+        if (FolderMode)
+          continue;
+        if (!ShowAllFiles)
+        {
+          unsigned i;
+          for (i = 0; i < Filters.Size(); i++)
+            if (DoesWildcardMatchName(Filters[i], fs2us(fi.Name)))
+              break;
+          if (i == Filters.Size())
+            continue;
+        }
+      }
+      files.Add(fi);
+    }
+  }
+
+  DirPrefix = pathPrefix;
+
+  _files = files;
+
+  SetItemText(IDT_BROWSE_FOLDER, DirPrefix);
+
+  _list.SetRedraw(false);
+  _list.DeleteAllItems();
+
+  LVITEMW item;
+
+  int index = 0;
+  int cursorIndex = -1;
+
+  #ifndef _SFX
+  if (_showDots && _topDirPrefix != DirPrefix)
+  {
+    item.iItem = index;
+    const UString itemName ("..");
+    if (selectedName.IsEmpty())
+      cursorIndex = index;
+    item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
+    int subItem = 0;
+    item.iSubItem = subItem++;
+    item.lParam = kParentIndex;
+    item.pszText = itemName.Ptr_non_const();
+    item.iImage = _extToIconMap.GetIconIndex(FILE_ATTRIBUTE_DIRECTORY, DirPrefix);
+    if (item.iImage < 0)
+      item.iImage = 0;
+    _list.InsertItem(&item);
+    _list.SetSubItem(index, subItem++, L"");
+    _list.SetSubItem(index, subItem++, L"");
+    index++;
+  }
+  #endif
+
+  for (unsigned i = 0; i < _files.Size(); i++, index++)
+  {
+    item.iItem = index;
+    const CFileInfo &fi = _files[i];
+    const UString name = fs2us(fi.Name);
+    if (!selectedName.IsEmpty() && CompareFileNames(name, selectedName) == 0)
+      cursorIndex = index;
+    item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
+    int subItem = 0;
+    item.iSubItem = subItem++;
+    item.lParam = i;
+    item.pszText = name.Ptr_non_const();
+
+    const UString fullPath = DirPrefix + name;
+    #ifndef UNDER_CE
+    if (isDrive)
+    {
+      if (GetRealIconIndex(fi.Name + FCHAR_PATH_SEPARATOR, FILE_ATTRIBUTE_DIRECTORY, item.iImage) == 0)
+        item.iImage = 0;
+    }
+    else
+    #endif
+      item.iImage = _extToIconMap.GetIconIndex(fi.Attrib, fullPath);
+    if (item.iImage < 0)
+      item.iImage = 0;
+    _list.InsertItem(&item);
+    wchar_t s[32];
+    {
+      s[0] = 0;
+      ConvertUtcFileTimeToString(fi.MTime, s,
+            #ifndef UNDER_CE
+              kTimestampPrintLevel_MIN
+            #else
+              kTimestampPrintLevel_DAY
+            #endif
+              );
+      _list.SetSubItem(index, subItem++, s);
+    }
+    {
+      s[0] = 0;
+      if (!fi.IsDir())
+        ConvertSizeToString(fi.Size, s);
+      _list.SetSubItem(index, subItem++, s);
+    }
+  }
+
+  if (_list.GetItemCount() > 0 && cursorIndex >= 0)
+    _list.SetItemState_FocusedSelected(cursorIndex);
+  _list.SortItems(CompareItems2, (LPARAM)this);
+  if (_list.GetItemCount() > 0 && cursorIndex < 0)
+    _list.SetItemState(0, LVIS_FOCUSED, LVIS_FOCUSED);
+  _list.EnsureVisible(_list.GetFocusedItem(), false);
+  _list.SetRedraw(true);
+  _list.InvalidateRect(NULL, true);
+  return S_OK;
+}
+
+HRESULT CBrowseDialog::Reload()
+{
+  UString selected;
+  int index = _list.GetNextSelectedItem(-1);
+  if (index >= 0)
+  {
+    int fileIndex = GetRealItemIndex(index);
+    if (fileIndex != kParentIndex)
+      selected = fs2us(_files[fileIndex].Name);
+  }
+  UString dirPathTemp = DirPrefix;
+  return Reload(dirPathTemp, selected);
+}
+
+void CBrowseDialog::OpenParentFolder()
+{
+  UString parent, selected;
+  if (GetParentPath(DirPrefix, parent, selected))
+  {
+    Reload(parent, selected);
+    SetPathEditText();
+  }
+}
+
+void CBrowseDialog::SetPathEditText()
+{
+  int index = _list.GetNextSelectedItem(-1);
+  if (index < 0)
+  {
+    if (FolderMode)
+      _pathEdit.SetText(DirPrefix);
+    return;
+  }
+  int fileIndex = GetRealItemIndex(index);
+  if (fileIndex == kParentIndex)
+  {
+    if (FolderMode)
+      _pathEdit.SetText(L".." WSTRING_PATH_SEPARATOR);
+    return;
+  }
+  const CFileInfo &file = _files[fileIndex];
+  if (file.IsDir())
+  {
+    if (!FolderMode)
+      return;
+    _pathEdit.SetText(fs2us(file.Name) + WCHAR_PATH_SEPARATOR);
+  }
+  else
+    _pathEdit.SetText(fs2us(file.Name));
+}
+
+void CBrowseDialog::OnCreateDir()
+{
+  UString name;
+  {
+    UString enteredName;
+    Dlg_CreateFolder((HWND)*this, enteredName);
+    if (enteredName.IsEmpty())
+      return;
+    if (!CorrectFsPath(DirPrefix, enteredName, name))
+    {
+      MessageBox_HResError((HWND)*this, ERROR_INVALID_NAME, name);
+      return;
+    }
+  }
+  if (name.IsEmpty())
+    return;
+
+  FString destPath;
+  if (GetFullPath(us2fs(DirPrefix), us2fs(name), destPath))
+  {
+    if (!NDir::CreateComplexDir(destPath))
+    {
+      MessageBox_HResError((HWND)*this, GetNormalizedError(), fs2us(destPath));
+    }
+    else
+    {
+      UString tempPath = DirPrefix;
+      Reload(tempPath, name);
+      SetPathEditText();
+    }
+    _list.SetFocus();
+  }
+}
+
+void CBrowseDialog::OnItemEnter()
+{
+  int index = _list.GetNextSelectedItem(-1);
+  if (index < 0)
+    return;
+  int fileIndex = GetRealItemIndex(index);
+  if (fileIndex == kParentIndex)
+    OpenParentFolder();
+  else
+  {
+    const CFileInfo &file = _files[fileIndex];
+    if (!file.IsDir())
+    {
+      if (!FolderMode)
+        FinishOnOK();
+      /*
+      MessageBox_Error_Global(*this, FolderMode ?
+            L"You must select some folder":
+            L"You must select some file");
+      */
+      return;
+    }
+    UString s = DirPrefix;
+    s += fs2us(file.Name);
+    s.Add_PathSepar();
+    HRESULT res = Reload(s, UString());
+    if (res != S_OK)
+      MessageBox_HResError(*this, res, s);
+    SetPathEditText();
+  }
+}
+
+void CBrowseDialog::FinishOnOK()
+{
+  UString s;
+  _pathEdit.GetText(s);
+  FString destPath;
+  if (!GetFullPath(us2fs(DirPrefix), us2fs(s), destPath))
+  {
+    MessageBox_HResError((HWND)*this, ERROR_INVALID_NAME, s);
+    return;
+  }
+  FilePath = fs2us(destPath);
+  if (FolderMode)
+    NormalizeDirPathPrefix(FilePath);
+  End(IDOK);
+}
+
+#endif
+
+bool MyBrowseForFolder(HWND owner, LPCWSTR title, LPCWSTR path, UString &resultPath)
+{
+  resultPath.Empty();
+
+  #ifndef UNDER_CE
+
+  #ifdef USE_MY_BROWSE_DIALOG
+  if (!IsSuperOrDevicePath(path))
+  #endif
+    return NShell::BrowseForFolder(owner, title, path, resultPath);
+
+  #endif
+
+  #ifdef USE_MY_BROWSE_DIALOG
+
+  CBrowseDialog dialog;
+  dialog.FolderMode = true;
+  if (title)
+    dialog.Title = title;
+  if (path)
+    dialog.FilePath = path;
+  if (dialog.Create(owner) != IDOK)
+    return false;
+  resultPath = dialog.FilePath;
+  #endif
+
+  return true;
+}
+
+bool MyBrowseForFile(HWND owner, LPCWSTR title, LPCWSTR path,
+    LPCWSTR filterDescription, LPCWSTR filter, UString &resultPath)
+{
+  resultPath.Empty();
+
+  #ifndef UNDER_CE
+
+  #ifdef USE_MY_BROWSE_DIALOG
+  if (!IsSuperOrDevicePath(path))
+  #endif
+  {
+    if (MyGetOpenFileName(owner, title, NULL, path, filterDescription, filter, resultPath))
+      return true;
+    #ifdef UNDER_CE
+    return false;
+    #else
+    // maybe we must use GetLastError in WinCE.
+    DWORD errorCode = CommDlgExtendedError();
+    const char *errorMessage = NULL;
+    switch (errorCode)
+    {
+      case 0: return false; // cancel or close obn dialog
+      case FNERR_INVALIDFILENAME: errorMessage = "Invalid File Name"; break;
+      default: errorMessage = "Open Dialog Error";
+    }
+    if (!errorMessage)
+      return false;
+    {
+      UString s (errorMessage);
+      s.Add_LF();
+      s += path;
+      MessageBox_Error_Global(owner, s);
+    }
+    #endif
+  }
+
+  #endif
+  
+  #ifdef USE_MY_BROWSE_DIALOG
+  CBrowseDialog dialog;
+  if (title)
+    dialog.Title = title;
+  if (path)
+    dialog.FilePath = path;
+  dialog.FolderMode = false;
+  if (filter)
+    dialog.SetFilter(filter);
+  if (filterDescription)
+    dialog.FilterDescription = filterDescription;
+  if (dialog.Create(owner) != IDOK)
+    return false;
+  resultPath = dialog.FilePath;
+  #endif
+
+  return true;
+}
+
+
+#ifdef _WIN32
+
+static void RemoveDotsAndSpaces(UString &path)
+{
+  while (!path.IsEmpty())
+  {
+    wchar_t c = path.Back();
+    if (c != ' ' && c != '.')
+      return;
+    path.DeleteBack();
+  }
+}
+
+
+bool CorrectFsPath(const UString &relBase, const UString &path2, UString &result)
+{
+  result.Empty();
+
+  UString path = path2;
+  path.Replace(L'/', WCHAR_PATH_SEPARATOR);
+  unsigned start = 0;
+  UString base;
+  
+  if (IsAbsolutePath(path))
+  {
+    #if defined(_WIN32) && !defined(UNDER_CE)
+    if (IsSuperOrDevicePath(path))
+    {
+      result = path;
+      return true;
+    }
+    #endif
+    int pos = GetRootPrefixSize(path);
+    if (pos > 0)
+      start = pos;
+  }
+  else
+  {
+    #if defined(_WIN32) && !defined(UNDER_CE)
+    if (IsSuperOrDevicePath(relBase))
+    {
+      result = path;
+      return true;
+    }
+    #endif
+    base = relBase;
+  }
+
+  /* We can't use backward, since we must change only disk paths */
+  /*
+  for (;;)
+  {
+    if (path.Len() <= start)
+      break;
+    if (DoesFileOrDirExist(us2fs(path)))
+      break;
+    if (path.Back() == WCHAR_PATH_SEPARATOR)
+    {
+      path.DeleteBack();
+      result.Insert(0, WCHAR_PATH_SEPARATOR);
+    }
+    int pos = path.ReverseFind(WCHAR_PATH_SEPARATOR) + 1;
+    UString cur = path.Ptr(pos);
+    RemoveDotsAndSpaces(cur);
+    result.Insert(0, cur);
+    path.DeleteFrom(pos);
+  }
+  result.Insert(0, path);
+  return true;
+  */
+
+  result += path.Left(start);
+  bool checkExist = true;
+  UString cur;
+
+  for (;;)
+  {
+    if (start == path.Len())
+      break;
+    int slashPos = path.Find(WCHAR_PATH_SEPARATOR, start);
+    cur.SetFrom(path.Ptr(start), (slashPos < 0 ? path.Len() : slashPos) - start);
+    if (checkExist)
+    {
+      CFileInfo fi;
+      if (fi.Find(us2fs(base + result + cur)))
+      {
+        if (!fi.IsDir())
+        {
+          result = path;
+          break;
+        }
+      }
+      else
+        checkExist = false;
+    }
+    if (!checkExist)
+      RemoveDotsAndSpaces(cur);
+    result += cur;
+    if (slashPos < 0)
+      break;
+    result.Add_PathSepar();
+    start = slashPos + 1;
+  }
+  
+  return true;
+}
+
+#else
+
+bool CorrectFsPath(const UString & /* relBase */, const UString &path, UString &result)
+{
+  result = path;
+  return true;
+}
+
+#endif
+
+bool Dlg_CreateFolder(HWND wnd, UString &destName)
+{
+  destName.Empty();
+  CComboDialog dlg;
+  LangString(IDS_CREATE_FOLDER, dlg.Title);
+  LangString(IDS_CREATE_FOLDER_NAME, dlg.Static);
+  LangString(IDS_CREATE_FOLDER_DEFAULT_NAME, dlg.Value);
+  if (dlg.Create(wnd) != IDOK)
+    return false;
+  destName = dlg.Value;
+  return true;
+}
diff --git a/CPP/7zip/UI/FileManager/BrowseDialog.h b/CPP/7zip/UI/FileManager/BrowseDialog.h
new file mode 100644
index 0000000..957af2e
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/BrowseDialog.h
@@ -0,0 +1,21 @@
+// BrowseDialog.h
+
+#ifndef __BROWSE_DIALOG_H
+#define __BROWSE_DIALOG_H
+
+#include "../../../Common/MyString.h"
+
+bool MyBrowseForFolder(HWND owner, LPCWSTR title, LPCWSTR path, UString &resultPath);
+bool MyBrowseForFile(HWND owner, LPCWSTR title, LPCWSTR path, LPCWSTR filterDescription, LPCWSTR filter, UString &resultPath);
+
+/* CorrectFsPath removes undesirable characters in names (dots and spaces at the end of file)
+   But it doesn't change "bad" name in any of the following cases:
+     - path is Super Path (with \\?\ prefix)
+     - path is relative and relBase is Super Path
+     - there is file or dir in filesystem with specified "bad" name */
+
+bool CorrectFsPath(const UString &relBase, const UString &path, UString &result);
+
+bool Dlg_CreateFolder(HWND wnd, UString &destName);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/BrowseDialog.rc b/CPP/7zip/UI/FileManager/BrowseDialog.rc
new file mode 100644
index 0000000..04a6ad6
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/BrowseDialog.rc
@@ -0,0 +1,25 @@
+#include "BrowseDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 256
+#define yc 320
+
+#define k_BROWSE_y_CtrlSize 14
+
+#define k_BROWSE_y_List  24
+
+IDD_BROWSE  DIALOG 0, 0, xs, ys  MY_MODAL_RESIZE_DIALOG_STYLE  MY_FONT
+CAPTION "7-Zip: Browse"
+{
+  EDITTEXT  IDE_BROWSE_PATH,   m, by - m - k_BROWSE_y_CtrlSize - k_BROWSE_y_CtrlSize - m, xc, k_BROWSE_y_CtrlSize, ES_AUTOHSCROLL
+  COMBOBOX  IDC_BROWSE_FILTER, m, by - m - k_BROWSE_y_CtrlSize, xc, 30, MY_COMBO
+
+  PUSHBUTTON  "OK",     IDOK,     bx2, by, bxs, bys
+  PUSHBUTTON  "Cancel", IDCANCEL, bx1, by, bxs, bys
+  PUSHBUTTON  "<--", IDB_BROWSE_PARENT,     m,      m, 24, bys
+  PUSHBUTTON  "+",  IDB_BROWSE_CREATE_DIR, m + 32, m, 24, bys
+  LTEXT    "", IDT_BROWSE_FOLDER, m + 64, m + 3, xc - 20, 8
+  CONTROL  "List1", IDL_BROWSE, "SysListView32",
+           LVS_REPORT | LVS_SHOWSELALWAYS | LVS_SHAREIMAGELISTS | LVS_SINGLESEL | WS_BORDER | WS_TABSTOP,
+           m, m + k_BROWSE_y_List, xc, yc - bys - m - k_BROWSE_y_List - k_BROWSE_y_CtrlSize - m - k_BROWSE_y_CtrlSize - m
+}
diff --git a/CPP/7zip/UI/FileManager/BrowseDialogRes.h b/CPP/7zip/UI/FileManager/BrowseDialogRes.h
new file mode 100644
index 0000000..aff84ec
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/BrowseDialogRes.h
@@ -0,0 +1,9 @@
+#define IDD_BROWSE  95
+
+#define IDL_BROWSE         100
+#define IDT_BROWSE_FOLDER  101
+#define IDE_BROWSE_PATH    102
+#define IDC_BROWSE_FILTER  103
+
+#define IDB_BROWSE_PARENT     110
+#define IDB_BROWSE_CREATE_DIR 112
diff --git a/CPP/7zip/UI/FileManager/ClassDefs.cpp b/CPP/7zip/UI/FileManager/ClassDefs.cpp
new file mode 100644
index 0000000..5c26904
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ClassDefs.cpp
@@ -0,0 +1,12 @@
+// ClassDefs.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyWindows.h"
+
+#include "../../../Common/MyInitGuid.h"
+
+#include "../Agent/Agent.h"
+
+#include "MyWindowsNew.h"
+#include "../Explorer/MyExplorerCommand.h"
diff --git a/CPP/7zip/UI/FileManager/ComboDialog.cpp b/CPP/7zip/UI/FileManager/ComboDialog.cpp
new file mode 100644
index 0000000..729743e
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ComboDialog.cpp
@@ -0,0 +1,64 @@
+// ComboDialog.cpp
+
+#include "StdAfx.h"
+#include "ComboDialog.h"
+
+#include "../../../Windows/Control/Static.h"
+
+#ifdef LANG
+#include "LangUtils.h"
+#endif
+
+using namespace NWindows;
+
+bool CComboDialog::OnInit()
+{
+  #ifdef LANG
+  LangSetDlgItems(*this, NULL, 0);
+  #endif
+  _comboBox.Attach(GetItem(IDC_COMBO));
+
+  /*
+  // why it doesn't work ?
+  DWORD style = _comboBox.GetStyle();
+  if (Sorted)
+    style |= CBS_SORT;
+  else
+    style &= ~CBS_SORT;
+  _comboBox.SetStyle(style);
+  */
+  SetText(Title);
+  
+  NControl::CStatic staticContol;
+  staticContol.Attach(GetItem(IDT_COMBO));
+  staticContol.SetText(Static);
+  _comboBox.SetText(Value);
+  FOR_VECTOR (i, Strings)
+    _comboBox.AddString(Strings[i]);
+  NormalizeSize();
+  return CModalDialog::OnInit();
+}
+
+bool CComboDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+  int mx, my;
+  GetMargins(8, mx, my);
+  int bx1, bx2, by;
+  GetItemSizes(IDCANCEL, bx1, by);
+  GetItemSizes(IDOK, bx2, by);
+  int y = ySize - my - by;
+  int x = xSize - mx - bx1;
+
+  InvalidateRect(NULL);
+
+  MoveItem(IDCANCEL, x, y, bx1, by);
+  MoveItem(IDOK, x - mx - bx2, y, bx2, by);
+  ChangeSubWindowSizeX(_comboBox, xSize - mx * 2);
+  return false;
+}
+
+void CComboDialog::OnOK()
+{
+  _comboBox.GetText(Value);
+  CModalDialog::OnOK();
+}
diff --git a/CPP/7zip/UI/FileManager/ComboDialog.h b/CPP/7zip/UI/FileManager/ComboDialog.h
new file mode 100644
index 0000000..29b28b5
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ComboDialog.h
@@ -0,0 +1,28 @@
+// ComboDialog.h
+
+#ifndef __COMBO_DIALOG_H
+#define __COMBO_DIALOG_H
+
+#include "../../../Windows/Control/ComboBox.h"
+#include "../../../Windows/Control/Dialog.h"
+
+#include "ComboDialogRes.h"
+
+class CComboDialog: public NWindows::NControl::CModalDialog
+{
+  NWindows::NControl::CComboBox _comboBox;
+  virtual void OnOK();
+  virtual bool OnInit();
+  virtual bool OnSize(WPARAM wParam, int xSize, int ySize);
+public:
+  // bool Sorted;
+  UString Title;
+  UString Static;
+  UString Value;
+  UStringVector Strings;
+  
+  // CComboDialog(): Sorted(false) {};
+  INT_PTR Create(HWND parentWindow = 0) { return CModalDialog::Create(IDD_COMBO, parentWindow); }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/ComboDialog.rc b/CPP/7zip/UI/FileManager/ComboDialog.rc
new file mode 100644
index 0000000..fddb748
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ComboDialog.rc
@@ -0,0 +1,16 @@
+#include "ComboDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 240
+#define yc 64
+
+IDD_COMBO  DIALOG  0, 0, xs, ys  MY_MODAL_RESIZE_DIALOG_STYLE  MY_FONT
+CAPTION "Combo"
+{
+  LTEXT      "", IDT_COMBO, m, m, xc, 8
+  COMBOBOX       IDC_COMBO, m, 20, xc, 65, MY_COMBO_WITH_EDIT
+  OK_CANCEL
+}
+
+#undef xc
+#undef yc
diff --git a/CPP/7zip/UI/FileManager/ComboDialogRes.h b/CPP/7zip/UI/FileManager/ComboDialogRes.h
new file mode 100644
index 0000000..a044797
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ComboDialogRes.h
@@ -0,0 +1,4 @@
+#define IDD_COMBO   98
+
+#define IDT_COMBO  100
+#define IDC_COMBO  101
diff --git a/CPP/7zip/UI/FileManager/Copy.bmp b/CPP/7zip/UI/FileManager/Copy.bmp
new file mode 100644
index 0000000..0f28a32
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Copy.bmp
diff --git a/CPP/7zip/UI/FileManager/Copy2.bmp b/CPP/7zip/UI/FileManager/Copy2.bmp
new file mode 100644
index 0000000..ba88ded
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Copy2.bmp
diff --git a/CPP/7zip/UI/FileManager/CopyDialog.cpp b/CPP/7zip/UI/FileManager/CopyDialog.cpp
new file mode 100644
index 0000000..4b17110
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/CopyDialog.cpp
@@ -0,0 +1,106 @@
+// CopyDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/FileName.h"
+
+#include "../../../Windows/Control/Static.h"
+
+#include "BrowseDialog.h"
+#include "CopyDialog.h"
+
+#ifdef LANG
+#include "LangUtils.h"
+#endif
+
+using namespace NWindows;
+
+bool CCopyDialog::OnInit()
+{
+  #ifdef LANG
+  LangSetDlgItems(*this, NULL, 0);
+  #endif
+  _path.Attach(GetItem(IDC_COPY));
+  SetText(Title);
+
+  NControl::CStatic staticContol;
+  staticContol.Attach(GetItem(IDT_COPY));
+  staticContol.SetText(Static);
+  #ifdef UNDER_CE
+  // we do it, since WinCE selects Value\something instead of Value !!!!
+  _path.AddString(Value);
+  #endif
+  FOR_VECTOR (i, Strings)
+    _path.AddString(Strings[i]);
+  _path.SetText(Value);
+  SetItemText(IDT_COPY_INFO, Info);
+  NormalizeSize(true);
+  return CModalDialog::OnInit();
+}
+
+bool CCopyDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+  int mx, my;
+  GetMargins(8, mx, my);
+  int bx1, bx2, by;
+  GetItemSizes(IDCANCEL, bx1, by);
+  GetItemSizes(IDOK, bx2, by);
+  int y = ySize - my - by;
+  int x = xSize - mx - bx1;
+
+  InvalidateRect(NULL);
+
+  {
+    RECT r;
+    GetClientRectOfItem(IDB_COPY_SET_PATH, r);
+    int bx = RECT_SIZE_X(r);
+    MoveItem(IDB_COPY_SET_PATH, xSize - mx - bx, r.top, bx, RECT_SIZE_Y(r));
+    ChangeSubWindowSizeX(_path, xSize - mx - mx - bx - mx);
+  }
+
+  {
+    RECT r;
+    GetClientRectOfItem(IDT_COPY_INFO, r);
+    NControl::CStatic staticContol;
+    staticContol.Attach(GetItem(IDT_COPY_INFO));
+    int yPos = r.top;
+    staticContol.Move(mx, yPos, xSize - mx * 2, y - 2 - yPos);
+  }
+
+  MoveItem(IDCANCEL, x, y, bx1, by);
+  MoveItem(IDOK, x - mx - bx2, y, bx2, by);
+
+  return false;
+}
+
+bool CCopyDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
+{
+  switch (buttonID)
+  {
+    case IDB_COPY_SET_PATH:
+      OnButtonSetPath();
+      return true;
+  }
+  return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+}
+
+void CCopyDialog::OnButtonSetPath()
+{
+  UString currentPath;
+  _path.GetText(currentPath);
+
+  const UString title = LangString(IDS_SET_FOLDER);
+
+  UString resultPath;
+  if (!MyBrowseForFolder(*this, title, currentPath, resultPath))
+    return;
+  NFile::NName::NormalizeDirPathPrefix(resultPath);
+  _path.SetCurSel(-1);
+  _path.SetText(resultPath);
+}
+
+void CCopyDialog::OnOK()
+{
+  _path.GetText(Value);
+  CModalDialog::OnOK();
+}
diff --git a/CPP/7zip/UI/FileManager/CopyDialog.h b/CPP/7zip/UI/FileManager/CopyDialog.h
new file mode 100644
index 0000000..30fde71
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/CopyDialog.h
@@ -0,0 +1,31 @@
+// CopyDialog.h
+
+#ifndef __COPY_DIALOG_H
+#define __COPY_DIALOG_H
+
+#include "../../../Windows/Control/ComboBox.h"
+#include "../../../Windows/Control/Dialog.h"
+
+#include "CopyDialogRes.h"
+
+const int kCopyDialog_NumInfoLines = 11;
+
+class CCopyDialog: public NWindows::NControl::CModalDialog
+{
+  NWindows::NControl::CComboBox _path;
+  virtual void OnOK();
+  virtual bool OnInit();
+  virtual bool OnSize(WPARAM wParam, int xSize, int ySize);
+  void OnButtonSetPath();
+  bool OnButtonClicked(int buttonID, HWND buttonHWND);
+public:
+  UString Title;
+  UString Static;
+  UString Value;
+  UString Info;
+  UStringVector Strings;
+
+  INT_PTR Create(HWND parentWindow = 0) { return CModalDialog::Create(IDD_COPY, parentWindow); }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/CopyDialog.rc b/CPP/7zip/UI/FileManager/CopyDialog.rc
new file mode 100644
index 0000000..73d3ea8
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/CopyDialog.rc
@@ -0,0 +1,20 @@
+#include "CopyDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 320
+#define yc 144
+
+#define y 40
+
+IDD_COPY  DIALOG  0, 0, xs, ys  MY_MODAL_RESIZE_DIALOG_STYLE  MY_FONT
+CAPTION "Copy"
+{
+  LTEXT       "",    IDT_COPY, m, m, xc, 8
+  COMBOBOX           IDC_COPY, m, 20, xc - bxsDots - m, 65, MY_COMBO_WITH_EDIT
+  PUSHBUTTON  "...", IDB_COPY_SET_PATH, xs - m - bxsDots, 18, bxsDots, bys, WS_GROUP
+  LTEXT       "",    IDT_COPY_INFO, m, y, xc, by - y - 1, SS_NOPREFIX | SS_LEFTNOWORDWRAP
+  OK_CANCEL
+}
+
+#undef xc
+#undef yc
diff --git a/CPP/7zip/UI/FileManager/CopyDialogRes.h b/CPP/7zip/UI/FileManager/CopyDialogRes.h
new file mode 100644
index 0000000..85f5a39
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/CopyDialogRes.h
@@ -0,0 +1,8 @@
+#define IDD_COPY  96
+
+#define IDT_COPY           100
+#define IDC_COPY           101
+#define IDB_COPY_SET_PATH  102
+#define IDT_COPY_INFO      103
+
+#define IDS_SET_FOLDER    6007
diff --git a/CPP/7zip/UI/FileManager/Delete.bmp b/CPP/7zip/UI/FileManager/Delete.bmp
new file mode 100644
index 0000000..d1004d8
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Delete.bmp
diff --git a/CPP/7zip/UI/FileManager/Delete2.bmp b/CPP/7zip/UI/FileManager/Delete2.bmp
new file mode 100644
index 0000000..60e08c6
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Delete2.bmp
diff --git a/CPP/7zip/UI/FileManager/DialogSize.h b/CPP/7zip/UI/FileManager/DialogSize.h
new file mode 100644
index 0000000..504541b
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/DialogSize.h
@@ -0,0 +1,16 @@
+// DialogSize.h
+
+#ifndef __DIALOG_SIZE_H
+#define __DIALOG_SIZE_H
+
+#include "../../../Windows/Control/Dialog.h"
+
+#ifdef UNDER_CE
+#define BIG_DIALOG_SIZE(x, y) bool isBig = NWindows::NControl::IsDialogSizeOK(x, y);
+#define SIZED_DIALOG(big) (isBig ? big : big ## _2)
+#else
+#define BIG_DIALOG_SIZE(x, y)
+#define SIZED_DIALOG(big) big
+#endif
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/EditDialog.cpp b/CPP/7zip/UI/FileManager/EditDialog.cpp
new file mode 100644
index 0000000..7f59672
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EditDialog.cpp
@@ -0,0 +1,57 @@
+// EditDialog.cpp
+
+#include "StdAfx.h"
+
+#include "EditDialog.h"
+
+#ifdef LANG
+#include "LangUtils.h"
+#endif
+
+bool CEditDialog::OnInit()
+{
+  #ifdef LANG
+  LangSetDlgItems(*this, NULL, 0);
+  #endif
+  _edit.Attach(GetItem(IDE_EDIT));
+
+  SetText(Title);
+  _edit.SetText(Text);
+
+  NormalizeSize();
+  return CModalDialog::OnInit();
+}
+
+// #define MY_CLOSE_BUTTON__ID IDCANCEL
+#define MY_CLOSE_BUTTON__ID IDCLOSE
+ 
+bool CEditDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+  int mx, my;
+  GetMargins(8, mx, my);
+  int bx1, by;
+  GetItemSizes(MY_CLOSE_BUTTON__ID, bx1, by);
+
+  // int bx2;
+  // GetItemSizes(IDOK, bx2, by);
+
+  int y = ySize - my - by;
+  int x = xSize - mx - bx1;
+
+  /*
+  RECT rect;
+  GetClientRect(&rect);
+  rect.top = y - my;
+  InvalidateRect(&rect);
+  */
+  InvalidateRect(NULL);
+
+  MoveItem(MY_CLOSE_BUTTON__ID, x, y, bx1, by);
+  // MoveItem(IDOK, x - mx - bx2, y, bx2, by);
+  /*
+  if (wParam == SIZE_MAXSHOW || wParam == SIZE_MAXIMIZED || wParam == SIZE_MAXHIDE)
+    mx = 0;
+  */
+  _edit.Move(mx, my, xSize - mx * 2, y - my * 2);
+  return false;
+}
diff --git a/CPP/7zip/UI/FileManager/EditDialog.h b/CPP/7zip/UI/FileManager/EditDialog.h
new file mode 100644
index 0000000..d820516
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EditDialog.h
@@ -0,0 +1,25 @@
+// EditDialog.h
+
+#ifndef __EDIT_DIALOG_H
+#define __EDIT_DIALOG_H
+
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/Edit.h"
+
+#include "EditDialogRes.h"
+
+class CEditDialog: public NWindows::NControl::CModalDialog
+{
+  NWindows::NControl::CEdit _edit;
+  virtual bool OnInit();
+  virtual bool OnSize(WPARAM wParam, int xSize, int ySize);
+public:
+  UString Title;
+  UString Text;
+
+  INT_PTR Create(HWND wndParent = 0) { return CModalDialog::Create(IDD_EDIT_DLG, wndParent); }
+
+  CEditDialog() {}
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/EditDialog.rc b/CPP/7zip/UI/FileManager/EditDialog.rc
new file mode 100644
index 0000000..cdb0b44
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EditDialog.rc
@@ -0,0 +1,15 @@
+#include "EditDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 320
+#define yc 240
+
+IDD_EDIT_DLG  DIALOG  0, 0, xs, ys  MY_MODAL_RESIZE_DIALOG_STYLE  MY_FONT
+CAPTION "Edit"
+{
+  // OK_CANCEL
+  MY_BUTTON__CLOSE
+
+  EDITTEXT  IDE_EDIT, m, m, xc, yc - bys - m, 
+        ES_MULTILINE | ES_READONLY | WS_VSCROLL | WS_HSCROLL | ES_WANTRETURN
+}
diff --git a/CPP/7zip/UI/FileManager/EditDialogRes.h b/CPP/7zip/UI/FileManager/EditDialogRes.h
new file mode 100644
index 0000000..58c5ca9
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EditDialogRes.h
@@ -0,0 +1,2 @@
+#define IDD_EDIT_DLG  94
+#define IDE_EDIT 100
diff --git a/CPP/7zip/UI/FileManager/EditPage.cpp b/CPP/7zip/UI/FileManager/EditPage.cpp
new file mode 100644
index 0000000..0108904
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EditPage.cpp
@@ -0,0 +1,147 @@
+// EditPage.cpp
+
+#include "StdAfx.h"
+
+#include "EditPage.h"
+#include "EditPageRes.h"
+
+#include "BrowseDialog.h"
+#include "HelpUtils.h"
+#include "LangUtils.h"
+#include "RegistryUtils.h"
+
+using namespace NWindows;
+
+static const UInt32 kLangIDs[] =
+{
+  IDT_EDIT_EDITOR,
+  IDT_EDIT_DIFF
+};
+
+static const UInt32 kLangIDs_Colon[] =
+{
+  IDT_EDIT_VIEWER
+};
+
+#define kEditTopic "FM/options.htm#editor"
+
+bool CEditPage::OnInit()
+{
+  _initMode = true;
+
+  LangSetDlgItems(*this, kLangIDs, ARRAY_SIZE(kLangIDs));
+  LangSetDlgItems_Colon(*this, kLangIDs_Colon, ARRAY_SIZE(kLangIDs_Colon));
+
+  _ctrls[0].Ctrl = IDE_EDIT_VIEWER; _ctrls[0].Button = IDB_EDIT_VIEWER;
+  _ctrls[1].Ctrl = IDE_EDIT_EDITOR; _ctrls[1].Button = IDB_EDIT_EDITOR;
+  _ctrls[2].Ctrl = IDE_EDIT_DIFF;   _ctrls[2].Button = IDB_EDIT_DIFF;
+
+  for (unsigned i = 0; i < 3; i++)
+  {
+    CEditPageCtrl &c = _ctrls[i];
+    c.WasChanged = false;
+    c.Edit.Attach(GetItem(c.Ctrl));
+    UString path;
+    if (i < 2)
+      ReadRegEditor(i > 0, path);
+    else
+      ReadRegDiff(path);
+    c.Edit.SetText(path);
+  }
+
+  _initMode = false;
+
+  return CPropertyPage::OnInit();
+}
+
+LONG CEditPage::OnApply()
+{
+  for (unsigned i = 0; i < 3; i++)
+  {
+    CEditPageCtrl &c = _ctrls[i];
+    if (c.WasChanged)
+    {
+      UString path;
+      c.Edit.GetText(path);
+      if (i < 2)
+        SaveRegEditor(i > 0, path);
+      else
+        SaveRegDiff(path);
+      c.WasChanged = false;
+    }
+  }
+  
+  return PSNRET_NOERROR;
+}
+
+void CEditPage::OnNotifyHelp()
+{
+  ShowHelpWindow(kEditTopic);
+}
+
+void SplitCmdLineSmart(const UString &cmd, UString &prg, UString &params);
+
+static void Edit_BrowseForFile(NWindows::NControl::CEdit &edit, HWND hwnd)
+{
+  UString cmd;
+  edit.GetText(cmd);
+
+  UString param;
+  UString prg;
+  
+  SplitCmdLineSmart(cmd, prg, param);
+
+  UString resPath;
+  
+  if (MyBrowseForFile(hwnd, 0, prg, NULL, L"*.exe", resPath))
+  {
+    resPath.Trim();
+    cmd = resPath;
+    /*
+    if (!param.IsEmpty() && !resPath.IsEmpty())
+    {
+      cmd.InsertAtFront(L'\"');
+      cmd += L'\"';
+      cmd.Add_Space();
+      cmd += param;
+    }
+    */
+
+    edit.SetText(cmd);
+    // Changed();
+  }
+}
+
+bool CEditPage::OnButtonClicked(int buttonID, HWND buttonHWND)
+{
+  for (unsigned i = 0; i < 3; i++)
+  {
+    CEditPageCtrl &c = _ctrls[i];
+    if (buttonID == c.Button)
+    {
+      Edit_BrowseForFile(c.Edit, *this);
+      return true;
+    }
+  }
+  
+  return CPropertyPage::OnButtonClicked(buttonID, buttonHWND);
+}
+
+bool CEditPage::OnCommand(int code, int itemID, LPARAM param)
+{
+  if (!_initMode && code == EN_CHANGE)
+  {
+    for (unsigned i = 0; i < 3; i++)
+    {
+      CEditPageCtrl &c = _ctrls[i];
+      if (itemID == c.Ctrl)
+      {
+        c.WasChanged = true;
+        Changed();
+        return true;
+      }
+    }
+  }
+
+  return CPropertyPage::OnCommand(code, itemID, param);
+}
diff --git a/CPP/7zip/UI/FileManager/EditPage.h b/CPP/7zip/UI/FileManager/EditPage.h
new file mode 100644
index 0000000..208edd8
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EditPage.h
@@ -0,0 +1,30 @@
+// EditPage.h
+ 
+#ifndef __EDIT_PAGE_H
+#define __EDIT_PAGE_H
+
+#include "../../../Windows/Control/PropertyPage.h"
+#include "../../../Windows/Control/Edit.h"
+
+struct CEditPageCtrl
+{
+  NWindows::NControl::CEdit Edit;
+  bool WasChanged;
+  int Ctrl;
+  int Button;
+};
+
+class CEditPage: public NWindows::NControl::CPropertyPage
+{
+  CEditPageCtrl _ctrls[3];
+
+  bool _initMode;
+public:
+  virtual bool OnInit();
+  virtual void OnNotifyHelp();
+  virtual bool OnCommand(int code, int itemID, LPARAM param);
+  virtual LONG OnApply();
+  virtual bool OnButtonClicked(int buttonID, HWND buttonHWND);
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/EditPage.rc b/CPP/7zip/UI/FileManager/EditPage.rc
new file mode 100644
index 0000000..38f74ea
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EditPage.rc
@@ -0,0 +1,19 @@
+#include "EditPageRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 240
+#define yc 80
+
+IDD_EDIT  MY_PAGE
+#include "EditPage2.rc"
+
+#ifdef UNDER_CE
+
+#undef xc
+
+#define xc SMALL_PAGE_SIZE_X
+
+IDD_EDIT_2  MY_PAGE
+#include "EditPage2.rc"
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/EditPage2.rc b/CPP/7zip/UI/FileManager/EditPage2.rc
new file mode 100644
index 0000000..2d6554f
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EditPage2.rc
@@ -0,0 +1,14 @@
+CAPTION "Editor"
+{
+  LTEXT       "&View:",   IDT_EDIT_VIEWER, m, m, xc, 8
+  EDITTEXT                IDE_EDIT_VIEWER, m, m + 12, xc - m - bxsDots, 14, ES_AUTOHSCROLL
+  PUSHBUTTON  "...",      IDB_EDIT_VIEWER, xs - m - bxsDots, m + 11, bxsDots, bys
+
+  LTEXT       "&Editor:", IDT_EDIT_EDITOR, m, m + 32, xc, 8
+  EDITTEXT                IDE_EDIT_EDITOR, m, m + 44, xc - m - bxsDots, 14, ES_AUTOHSCROLL
+  PUSHBUTTON  "...",      IDB_EDIT_EDITOR, xs - m - bxsDots, m + 43, bxsDots, bys
+
+  LTEXT       "&Diff:",   IDT_EDIT_DIFF,   m, m + 64, xc, 8
+  EDITTEXT                IDE_EDIT_DIFF,   m, m + 76, xc - m - bxsDots, 14, ES_AUTOHSCROLL
+  PUSHBUTTON  "...",      IDB_EDIT_DIFF,   xs - m - bxsDots, m + 75, bxsDots, bys
+}
diff --git a/CPP/7zip/UI/FileManager/EditPageRes.h b/CPP/7zip/UI/FileManager/EditPageRes.h
new file mode 100644
index 0000000..017d702
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EditPageRes.h
@@ -0,0 +1,15 @@
+#define IDD_EDIT     2103
+#define IDD_EDIT_2  12103
+
+#define IDT_EDIT_VIEWER    543
+#define IDT_EDIT_EDITOR   2104
+#define IDT_EDIT_DIFF     2105
+
+#define IDE_EDIT_VIEWER    100
+#define IDB_EDIT_VIEWER    101
+
+#define IDE_EDIT_EDITOR    102
+#define IDB_EDIT_EDITOR    103
+
+#define IDE_EDIT_DIFF      104
+#define IDB_EDIT_DIFF      105
diff --git a/CPP/7zip/UI/FileManager/EnumFormatEtc.cpp b/CPP/7zip/UI/FileManager/EnumFormatEtc.cpp
new file mode 100644
index 0000000..389aa3e
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EnumFormatEtc.cpp
@@ -0,0 +1,108 @@
+// EnumFormatEtc.cpp
+
+#include "StdAfx.h"
+
+#include "EnumFormatEtc.h"
+#include "MyCom2.h"
+
+class CEnumFormatEtc :
+public IEnumFORMATETC,
+public CMyUnknownImp
+{
+public:
+  MY_UNKNOWN_IMP1_MT(IEnumFORMATETC)
+    
+  STDMETHOD(Next)(ULONG celt, FORMATETC *rgelt, ULONG *pceltFetched);
+  STDMETHOD(Skip)(ULONG celt);
+  STDMETHOD(Reset)(void);
+  STDMETHOD(Clone)(IEnumFORMATETC **ppEnumFormatEtc);
+  
+  CEnumFormatEtc(const FORMATETC *pFormatEtc, ULONG numFormats);
+  ~CEnumFormatEtc();
+  
+private:
+  LONG m_RefCount;
+  ULONG m_NumFormats;
+  FORMATETC *m_Formats;
+  ULONG m_Index;
+};
+
+static void DeepCopyFormatEtc(FORMATETC *dest, const FORMATETC *src)
+{
+  *dest = *src;
+  if (src->ptd)
+  {
+    dest->ptd = (DVTARGETDEVICE*)CoTaskMemAlloc(sizeof(DVTARGETDEVICE));
+    *(dest->ptd) = *(src->ptd);
+  }
+}
+
+CEnumFormatEtc::CEnumFormatEtc(const FORMATETC *pFormatEtc, ULONG numFormats)
+{
+  m_RefCount = 1;
+  m_Index = 0;
+  m_NumFormats = 0;
+  m_Formats = new FORMATETC[numFormats];
+  // if (m_Formats)
+  {
+    m_NumFormats = numFormats;
+    for (ULONG i = 0; i < numFormats; i++)
+      DeepCopyFormatEtc(&m_Formats[i], &pFormatEtc[i]);
+  }
+}
+
+CEnumFormatEtc::~CEnumFormatEtc()
+{
+  if (m_Formats)
+  {
+    for (ULONG i = 0; i < m_NumFormats; i++)
+      if (m_Formats[i].ptd)
+        CoTaskMemFree(m_Formats[i].ptd);
+    delete []m_Formats;
+  }
+}
+
+STDMETHODIMP CEnumFormatEtc::Next(ULONG celt, FORMATETC *pFormatEtc, ULONG *pceltFetched)
+{
+  ULONG copied  = 0;
+  if (celt == 0 || pFormatEtc == 0)
+    return E_INVALIDARG;
+  while (m_Index < m_NumFormats && copied < celt)
+  {
+    DeepCopyFormatEtc(&pFormatEtc[copied], &m_Formats[m_Index]);
+    copied++;
+    m_Index++;
+  }
+  if (pceltFetched != 0)
+    *pceltFetched = copied;
+  return (copied == celt) ? S_OK : S_FALSE;
+}
+
+STDMETHODIMP CEnumFormatEtc::Skip(ULONG celt)
+{
+  m_Index += celt;
+  return (m_Index <= m_NumFormats) ? S_OK : S_FALSE;
+}
+
+STDMETHODIMP CEnumFormatEtc::Reset(void)
+{
+  m_Index = 0;
+  return S_OK;
+}
+
+STDMETHODIMP CEnumFormatEtc::Clone(IEnumFORMATETC ** ppEnumFormatEtc)
+{
+  HRESULT hResult = CreateEnumFormatEtc(m_NumFormats, m_Formats, ppEnumFormatEtc);
+  if (hResult == S_OK)
+    ((CEnumFormatEtc *)*ppEnumFormatEtc)->m_Index = m_Index;
+  return hResult;
+}
+
+// replacement for SHCreateStdEnumFmtEtc
+HRESULT CreateEnumFormatEtc(UINT numFormats, const FORMATETC *formats, IEnumFORMATETC **enumFormat)
+{
+  if (numFormats == 0 || formats == 0 || enumFormat == 0)
+    return E_INVALIDARG;
+  *enumFormat = new CEnumFormatEtc(formats, numFormats);
+  return (*enumFormat) ? S_OK : E_OUTOFMEMORY;
+}
diff --git a/CPP/7zip/UI/FileManager/EnumFormatEtc.h b/CPP/7zip/UI/FileManager/EnumFormatEtc.h
new file mode 100644
index 0000000..93a53cb
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EnumFormatEtc.h
@@ -0,0 +1,10 @@
+// EnumFormatEtc.h
+
+#ifndef __ENUMFORMATETC_H
+#define __ENUMFORMATETC_H
+
+#include "../../../Common/MyWindows.h"
+
+HRESULT CreateEnumFormatEtc(UINT numFormats, const FORMATETC *formats, IEnumFORMATETC **enumFormat);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/Extract.bmp b/CPP/7zip/UI/FileManager/Extract.bmp
new file mode 100644
index 0000000..0aeba92
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Extract.bmp
diff --git a/CPP/7zip/UI/FileManager/Extract2.bmp b/CPP/7zip/UI/FileManager/Extract2.bmp
new file mode 100644
index 0000000..a7e5775
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Extract2.bmp
diff --git a/CPP/7zip/UI/FileManager/ExtractCallback.cpp b/CPP/7zip/UI/FileManager/ExtractCallback.cpp
new file mode 100644
index 0000000..232717f
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ExtractCallback.cpp
@@ -0,0 +1,1049 @@
+// ExtractCallback.cpp
+
+#include "StdAfx.h"
+
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/Lang.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#include "../../Common/FilePathAutoRename.h"
+#include "../../Common/StreamUtils.h"
+#include "../Common/ExtractingFilePath.h"
+
+#ifndef _SFX
+#include "../Common/ZipRegistry.h"
+#endif
+
+#include "../GUI/ExtractRes.h"
+#include "resourceGui.h"
+
+#include "ExtractCallback.h"
+#include "FormatUtils.h"
+#include "LangUtils.h"
+#include "OverwriteDialog.h"
+#ifndef _NO_CRYPTO
+#include "PasswordDialog.h"
+#endif
+#include "PropertyName.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NFind;
+
+CExtractCallbackImp::~CExtractCallbackImp() {}
+
+void CExtractCallbackImp::Init()
+{
+  _lang_Extracting = LangString(IDS_PROGRESS_EXTRACTING);
+  _lang_Testing = LangString(IDS_PROGRESS_TESTING);
+  _lang_Skipping = LangString(IDS_PROGRESS_SKIPPING);
+  _lang_Reading = "Reading";
+
+  NumArchiveErrors = 0;
+  ThereAreMessageErrors = false;
+  #ifndef _SFX
+  NumFolders = NumFiles = 0;
+  NeedAddFile = false;
+  #endif
+}
+
+void CExtractCallbackImp::AddError_Message(LPCWSTR s)
+{
+  ThereAreMessageErrors = true;
+  ProgressDialog->Sync.AddError_Message(s);
+}
+
+#ifndef _SFX
+
+STDMETHODIMP CExtractCallbackImp::SetNumFiles(UInt64
+  #ifndef _SFX
+  numFiles
+  #endif
+  )
+{
+  #ifndef _SFX
+  ProgressDialog->Sync.Set_NumFilesTotal(numFiles);
+  #endif
+  return S_OK;
+}
+
+#endif
+
+STDMETHODIMP CExtractCallbackImp::SetTotal(UInt64 total)
+{
+  ProgressDialog->Sync.Set_NumBytesTotal(total);
+  return S_OK;
+}
+
+STDMETHODIMP CExtractCallbackImp::SetCompleted(const UInt64 *value)
+{
+  return ProgressDialog->Sync.Set_NumBytesCur(value);
+}
+
+HRESULT CExtractCallbackImp::Open_CheckBreak()
+{
+  return ProgressDialog->Sync.CheckStop();
+}
+
+HRESULT CExtractCallbackImp::Open_SetTotal(const UInt64 *files, const UInt64 *bytes)
+{
+  HRESULT res = S_OK;
+  if (!MultiArcMode)
+  {
+    if (files)
+    {
+      _totalFilesDefined = true;
+      // res = ProgressDialog->Sync.Set_NumFilesTotal(*files);
+    }
+    else
+      _totalFilesDefined = false;
+
+    if (bytes)
+    {
+      _totalBytesDefined = true;
+      ProgressDialog->Sync.Set_NumBytesTotal(*bytes);
+    }
+    else
+      _totalBytesDefined = false;
+  }
+
+  return res;
+}
+
+HRESULT CExtractCallbackImp::Open_SetCompleted(const UInt64 *files, const UInt64 *bytes)
+{
+  if (!MultiArcMode)
+  {
+    if (files)
+    {
+      ProgressDialog->Sync.Set_NumFilesCur(*files);
+    }
+
+    if (bytes)
+    {
+    }
+  }
+
+  return ProgressDialog->Sync.CheckStop();
+}
+
+HRESULT CExtractCallbackImp::Open_Finished()
+{
+  return ProgressDialog->Sync.CheckStop();
+}
+
+#ifndef _NO_CRYPTO
+
+HRESULT CExtractCallbackImp::Open_CryptoGetTextPassword(BSTR *password)
+{
+  return CryptoGetTextPassword(password);
+}
+
+/*
+HRESULT CExtractCallbackImp::Open_GetPasswordIfAny(bool &passwordIsDefined, UString &password)
+{
+  passwordIsDefined = PasswordIsDefined;
+  password = Password;
+  return S_OK;
+}
+
+bool CExtractCallbackImp::Open_WasPasswordAsked()
+{
+  return PasswordWasAsked;
+}
+
+void CExtractCallbackImp::Open_Clear_PasswordWasAsked_Flag()
+{
+  PasswordWasAsked = false;
+}
+*/
+
+#endif
+
+
+#ifndef _SFX
+STDMETHODIMP CExtractCallbackImp::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize)
+{
+  ProgressDialog->Sync.Set_Ratio(inSize, outSize);
+  return S_OK;
+}
+#endif
+
+/*
+STDMETHODIMP CExtractCallbackImp::SetTotalFiles(UInt64 total)
+{
+  ProgressDialog->Sync.SetNumFilesTotal(total);
+  return S_OK;
+}
+
+STDMETHODIMP CExtractCallbackImp::SetCompletedFiles(const UInt64 *value)
+{
+  if (value != NULL)
+    ProgressDialog->Sync.SetNumFilesCur(*value);
+  return S_OK;
+}
+*/
+
+STDMETHODIMP CExtractCallbackImp::AskOverwrite(
+    const wchar_t *existName, const FILETIME *existTime, const UInt64 *existSize,
+    const wchar_t *newName, const FILETIME *newTime, const UInt64 *newSize,
+    Int32 *answer)
+{
+  COverwriteDialog dialog;
+
+  dialog.OldFileInfo.SetTime(existTime);
+  dialog.OldFileInfo.SetSize(existSize);
+  dialog.OldFileInfo.Name = existName;
+
+  dialog.NewFileInfo.SetTime(newTime);
+  dialog.NewFileInfo.SetSize(newSize);
+  dialog.NewFileInfo.Name = newName;
+  
+  ProgressDialog->WaitCreating();
+  INT_PTR writeAnswer = dialog.Create(*ProgressDialog);
+  
+  switch (writeAnswer)
+  {
+    case IDCANCEL:        *answer = NOverwriteAnswer::kCancel; return E_ABORT;
+    case IDYES:           *answer = NOverwriteAnswer::kYes; break;
+    case IDNO:            *answer = NOverwriteAnswer::kNo; break;
+    case IDB_YES_TO_ALL:  *answer = NOverwriteAnswer::kYesToAll; break;
+    case IDB_NO_TO_ALL:   *answer = NOverwriteAnswer::kNoToAll; break;
+    case IDB_AUTO_RENAME: *answer = NOverwriteAnswer::kAutoRename; break;
+    default: return E_FAIL;
+  }
+  return S_OK;
+}
+
+
+STDMETHODIMP CExtractCallbackImp::PrepareOperation(const wchar_t *name, Int32 isFolder, Int32 askExtractMode, const UInt64 * /* position */)
+{
+  _isFolder = IntToBool(isFolder);
+  _currentFilePath = name;
+
+  const UString *msg = &_lang_Empty;
+  switch (askExtractMode)
+  {
+    case NArchive::NExtract::NAskMode::kExtract: msg = &_lang_Extracting; break;
+    case NArchive::NExtract::NAskMode::kTest:    msg = &_lang_Testing; break;
+    case NArchive::NExtract::NAskMode::kSkip:    msg = &_lang_Skipping; break;
+    case NArchive::NExtract::NAskMode::kReadExternal: msg = &_lang_Reading; break;
+    // default: s = "Unknown operation";
+  }
+
+  return ProgressDialog->Sync.Set_Status2(*msg, name, IntToBool(isFolder));
+}
+
+STDMETHODIMP CExtractCallbackImp::MessageError(const wchar_t *s)
+{
+  AddError_Message(s);
+  return S_OK;
+}
+
+HRESULT CExtractCallbackImp::MessageError(const char *message, const FString &path)
+{
+  ThereAreMessageErrors = true;
+  ProgressDialog->Sync.AddError_Message_Name(GetUnicodeString(message), fs2us(path));
+  return S_OK;
+}
+
+#ifndef _SFX
+
+STDMETHODIMP CExtractCallbackImp::ShowMessage(const wchar_t *s)
+{
+  AddError_Message(s);
+  return S_OK;
+}
+
+#endif
+
+void SetExtractErrorMessage(Int32 opRes, Int32 encrypted, const wchar_t *fileName, UString &s);
+void SetExtractErrorMessage(Int32 opRes, Int32 encrypted, const wchar_t *fileName, UString &s)
+{
+  s.Empty();
+
+  if (opRes == NArchive::NExtract::NOperationResult::kOK)
+    return;
+
+  UINT messageID = 0;
+  UINT id = 0;
+
+  switch (opRes)
+  {
+    case NArchive::NExtract::NOperationResult::kUnsupportedMethod:
+      messageID = IDS_EXTRACT_MESSAGE_UNSUPPORTED_METHOD;
+      id = IDS_EXTRACT_MSG_UNSUPPORTED_METHOD;
+      break;
+    case NArchive::NExtract::NOperationResult::kDataError:
+      messageID = encrypted ?
+          IDS_EXTRACT_MESSAGE_DATA_ERROR_ENCRYPTED:
+          IDS_EXTRACT_MESSAGE_DATA_ERROR;
+      id = IDS_EXTRACT_MSG_DATA_ERROR;
+      break;
+    case NArchive::NExtract::NOperationResult::kCRCError:
+      messageID = encrypted ?
+          IDS_EXTRACT_MESSAGE_CRC_ERROR_ENCRYPTED:
+          IDS_EXTRACT_MESSAGE_CRC_ERROR;
+      id = IDS_EXTRACT_MSG_CRC_ERROR;
+      break;
+    case NArchive::NExtract::NOperationResult::kUnavailable:
+      id = IDS_EXTRACT_MSG_UNAVAILABLE_DATA;
+      break;
+    case NArchive::NExtract::NOperationResult::kUnexpectedEnd:
+      id = IDS_EXTRACT_MSG_UEXPECTED_END;
+      break;
+    case NArchive::NExtract::NOperationResult::kDataAfterEnd:
+      id = IDS_EXTRACT_MSG_DATA_AFTER_END;
+      break;
+    case NArchive::NExtract::NOperationResult::kIsNotArc:
+      id = IDS_EXTRACT_MSG_IS_NOT_ARC;
+      break;
+    case NArchive::NExtract::NOperationResult::kHeadersError:
+      id = IDS_EXTRACT_MSG_HEADERS_ERROR;
+      break;
+    case NArchive::NExtract::NOperationResult::kWrongPassword:
+      id = IDS_EXTRACT_MSG_WRONG_PSW_CLAIM;
+      break;
+    /*
+    default:
+      messageID = IDS_EXTRACT_MESSAGE_UNKNOWN_ERROR;
+      break;
+    */
+  }
+
+  UString msg;
+  UString msgOld;
+
+  #ifndef _SFX
+  if (id != 0)
+    LangString_OnlyFromLangFile(id, msg);
+  if (messageID != 0 && msg.IsEmpty())
+    LangString_OnlyFromLangFile(messageID, msgOld);
+  #endif
+
+  if (msg.IsEmpty() && !msgOld.IsEmpty())
+    s = MyFormatNew(msgOld, fileName);
+  else
+  {
+    if (msg.IsEmpty() && id != 0)
+      LangString(id, msg);
+    if (!msg.IsEmpty())
+      s += msg;
+    else
+    {
+      s += "Error #";
+      s.Add_UInt32(opRes);
+    }
+
+    if (encrypted && opRes != NArchive::NExtract::NOperationResult::kWrongPassword)
+    {
+      // s += " : ";
+      // AddLangString(s, IDS_EXTRACT_MSG_ENCRYPTED);
+      s += " : ";
+      AddLangString(s, IDS_EXTRACT_MSG_WRONG_PSW_GUESS);
+    }
+    s += " : ";
+    s += fileName;
+  }
+}
+
+STDMETHODIMP CExtractCallbackImp::SetOperationResult(Int32 opRes, Int32 encrypted)
+{
+  switch (opRes)
+  {
+    case NArchive::NExtract::NOperationResult::kOK:
+      break;
+    default:
+    {
+      UString s;
+      SetExtractErrorMessage(opRes, encrypted, _currentFilePath, s);
+      Add_ArchiveName_Error();
+      AddError_Message(s);
+    }
+  }
+  
+  #ifndef _SFX
+  if (_isFolder)
+    NumFolders++;
+  else
+    NumFiles++;
+  ProgressDialog->Sync.Set_NumFilesCur(NumFiles);
+  #endif
+  
+  return S_OK;
+}
+
+STDMETHODIMP CExtractCallbackImp::ReportExtractResult(Int32 opRes, Int32 encrypted, const wchar_t *name)
+{
+  if (opRes != NArchive::NExtract::NOperationResult::kOK)
+  {
+    UString s;
+    SetExtractErrorMessage(opRes, encrypted, name, s);
+    Add_ArchiveName_Error();
+    AddError_Message(s);
+  }
+  return S_OK;
+}
+
+////////////////////////////////////////
+// IExtractCallbackUI
+
+HRESULT CExtractCallbackImp::BeforeOpen(const wchar_t *name, bool /* testMode */)
+{
+  #ifndef _SFX
+  RINOK(ProgressDialog->Sync.CheckStop());
+  ProgressDialog->Sync.Set_TitleFileName(name);
+  #endif
+  _currentArchivePath = name;
+  return S_OK;
+}
+
+HRESULT CExtractCallbackImp::SetCurrentFilePath2(const wchar_t *path)
+{
+  _currentFilePath = path;
+  #ifndef _SFX
+  ProgressDialog->Sync.Set_FilePath(path);
+  #endif
+  return S_OK;
+}
+
+#ifndef _SFX
+
+HRESULT CExtractCallbackImp::SetCurrentFilePath(const wchar_t *path)
+{
+  #ifndef _SFX
+  if (NeedAddFile)
+    NumFiles++;
+  NeedAddFile = true;
+  ProgressDialog->Sync.Set_NumFilesCur(NumFiles);
+  #endif
+  return SetCurrentFilePath2(path);
+}
+
+#endif
+
+UString HResultToMessage(HRESULT errorCode);
+
+static const UInt32 k_ErrorFlagsIds[] =
+{
+  IDS_EXTRACT_MSG_IS_NOT_ARC,
+  IDS_EXTRACT_MSG_HEADERS_ERROR,
+  IDS_EXTRACT_MSG_HEADERS_ERROR,
+  IDS_OPEN_MSG_UNAVAILABLE_START,
+  IDS_OPEN_MSG_UNCONFIRMED_START,
+  IDS_EXTRACT_MSG_UEXPECTED_END,
+  IDS_EXTRACT_MSG_DATA_AFTER_END,
+  IDS_EXTRACT_MSG_UNSUPPORTED_METHOD,
+  IDS_OPEN_MSG_UNSUPPORTED_FEATURE,
+  IDS_EXTRACT_MSG_DATA_ERROR,
+  IDS_EXTRACT_MSG_CRC_ERROR
+};
+
+static void AddNewLineString(UString &s, const UString &m)
+{
+  s += m;
+  s.Add_LF();
+}
+
+UString GetOpenArcErrorMessage(UInt32 errorFlags);
+UString GetOpenArcErrorMessage(UInt32 errorFlags)
+{
+  UString s;
+
+  for (unsigned i = 0; i < ARRAY_SIZE(k_ErrorFlagsIds); i++)
+  {
+    UInt32 f = ((UInt32)1 << i);
+    if ((errorFlags & f) == 0)
+      continue;
+    UInt32 id = k_ErrorFlagsIds[i];
+    UString m = LangString(id);
+    if (m.IsEmpty())
+      continue;
+    if (f == kpv_ErrorFlags_EncryptedHeadersError)
+    {
+      m += " : ";
+      AddLangString(m, IDS_EXTRACT_MSG_WRONG_PSW_GUESS);
+    }
+    if (!s.IsEmpty())
+      s.Add_LF();
+    s += m;
+    errorFlags &= ~f;
+  }
+  
+  if (errorFlags != 0)
+  {
+    char sz[16];
+    sz[0] = '0';
+    sz[1] = 'x';
+    ConvertUInt32ToHex(errorFlags, sz + 2);
+    if (!s.IsEmpty())
+      s.Add_LF();
+    s += sz;
+  }
+  
+  return s;
+}
+
+static void ErrorInfo_Print(UString &s, const CArcErrorInfo &er)
+{
+  UInt32 errorFlags = er.GetErrorFlags();
+  UInt32 warningFlags = er.GetWarningFlags();
+
+  if (errorFlags != 0)
+    AddNewLineString(s, GetOpenArcErrorMessage(errorFlags));
+      
+  if (!er.ErrorMessage.IsEmpty())
+    AddNewLineString(s, er.ErrorMessage);
+  
+  if (warningFlags != 0)
+  {
+    s += GetNameOfProperty(kpidWarningFlags, L"Warnings");
+    s += ":";
+    s.Add_LF();
+    AddNewLineString(s, GetOpenArcErrorMessage(warningFlags));
+  }
+  
+  if (!er.WarningMessage.IsEmpty())
+  {
+    s += GetNameOfProperty(kpidWarning, L"Warning");
+    s += ": ";
+    s += er.WarningMessage;
+    s.Add_LF();
+  }
+}
+
+static UString GetBracedType(const wchar_t *type)
+{
+  UString s ('[');
+  s += type;
+  s += ']';
+  return s;
+}
+
+void OpenResult_GUI(UString &s, const CCodecs *codecs, const CArchiveLink &arcLink, const wchar_t *name, HRESULT result);
+void OpenResult_GUI(UString &s, const CCodecs *codecs, const CArchiveLink &arcLink, const wchar_t *name, HRESULT result)
+{
+  FOR_VECTOR (level, arcLink.Arcs)
+  {
+    const CArc &arc = arcLink.Arcs[level];
+    const CArcErrorInfo &er = arc.ErrorInfo;
+
+    if (!er.IsThereErrorOrWarning() && er.ErrorFormatIndex < 0)
+      continue;
+
+    if (s.IsEmpty())
+    {
+      s += name;
+      s.Add_LF();
+    }
+    
+    if (level != 0)
+    {
+      AddNewLineString(s, arc.Path);
+    }
+      
+    ErrorInfo_Print(s, er);
+
+    if (er.ErrorFormatIndex >= 0)
+    {
+      AddNewLineString(s, GetNameOfProperty(kpidWarning, L"Warning"));
+      if (arc.FormatIndex == er.ErrorFormatIndex)
+      {
+        AddNewLineString(s, LangString(IDS_IS_OPEN_WITH_OFFSET));
+      }
+      else
+      {
+        AddNewLineString(s, MyFormatNew(IDS_CANT_OPEN_AS_TYPE, GetBracedType(codecs->GetFormatNamePtr(er.ErrorFormatIndex))));
+        AddNewLineString(s, MyFormatNew(IDS_IS_OPEN_AS_TYPE, GetBracedType(codecs->GetFormatNamePtr(arc.FormatIndex))));
+      }
+    }
+  }
+
+  if (arcLink.NonOpen_ErrorInfo.ErrorFormatIndex >= 0 || result != S_OK)
+  {
+    s += name;
+    s.Add_LF();
+    if (!arcLink.Arcs.IsEmpty())
+      AddNewLineString(s, arcLink.NonOpen_ArcPath);
+    
+    if (arcLink.NonOpen_ErrorInfo.ErrorFormatIndex >= 0 || result == S_FALSE)
+    {
+      UINT id = IDS_CANT_OPEN_ARCHIVE;
+      UString param;
+      if (arcLink.PasswordWasAsked)
+        id = IDS_CANT_OPEN_ENCRYPTED_ARCHIVE;
+      else if (arcLink.NonOpen_ErrorInfo.ErrorFormatIndex >= 0)
+      {
+        id = IDS_CANT_OPEN_AS_TYPE;
+        param = GetBracedType(codecs->GetFormatNamePtr(arcLink.NonOpen_ErrorInfo.ErrorFormatIndex));
+      }
+      UString s2 = MyFormatNew(id, param);
+      s2.Replace(L" ''", L"");
+      s2.Replace(L"''", L"");
+      s += s2;
+    }
+    else
+      s += HResultToMessage(result);
+
+    s.Add_LF();
+    ErrorInfo_Print(s, arcLink.NonOpen_ErrorInfo);
+  }
+
+  if (!s.IsEmpty() && s.Back() == '\n')
+    s.DeleteBack();
+}
+
+HRESULT CExtractCallbackImp::OpenResult(const CCodecs *codecs, const CArchiveLink &arcLink, const wchar_t *name, HRESULT result)
+{
+  _currentArchivePath = name;
+  _needWriteArchivePath = true;
+
+  UString s;
+  OpenResult_GUI(s, codecs, arcLink, name, result);
+  if (!s.IsEmpty())
+  {
+    NumArchiveErrors++;
+    AddError_Message(s);
+    _needWriteArchivePath = false;
+  }
+
+  return S_OK;
+}
+
+HRESULT CExtractCallbackImp::ThereAreNoFiles()
+{
+  return S_OK;
+}
+
+void CExtractCallbackImp::Add_ArchiveName_Error()
+{
+  if (_needWriteArchivePath)
+  {
+    if (!_currentArchivePath.IsEmpty())
+      AddError_Message(_currentArchivePath);
+    _needWriteArchivePath = false;
+  }
+}
+
+HRESULT CExtractCallbackImp::ExtractResult(HRESULT result)
+{
+  if (result == S_OK)
+    return result;
+  NumArchiveErrors++;
+  if (result == E_ABORT
+      || result == HRESULT_FROM_WIN32(ERROR_DISK_FULL)
+      )
+    return result;
+
+  Add_ArchiveName_Error();
+  if (!_currentFilePath.IsEmpty())
+    MessageError(_currentFilePath);
+  MessageError(NError::MyFormatMessage(result));
+  return S_OK;
+}
+
+#ifndef _NO_CRYPTO
+
+HRESULT CExtractCallbackImp::SetPassword(const UString &password)
+{
+  PasswordIsDefined = true;
+  Password = password;
+  return S_OK;
+}
+
+STDMETHODIMP CExtractCallbackImp::CryptoGetTextPassword(BSTR *password)
+{
+  PasswordWasAsked = true;
+  if (!PasswordIsDefined)
+  {
+    CPasswordDialog dialog;
+    #ifndef _SFX
+    bool showPassword = NExtract::Read_ShowPassword();
+    dialog.ShowPassword = showPassword;
+    #endif
+    ProgressDialog->WaitCreating();
+    if (dialog.Create(*ProgressDialog) != IDOK)
+      return E_ABORT;
+    Password = dialog.Password;
+    PasswordIsDefined = true;
+    #ifndef _SFX
+    if (dialog.ShowPassword != showPassword)
+      NExtract::Save_ShowPassword(dialog.ShowPassword);
+    #endif
+  }
+  return StringToBstr(Password, password);
+}
+
+#endif
+
+#ifndef _SFX
+
+STDMETHODIMP CExtractCallbackImp::AskWrite(
+    const wchar_t *srcPath, Int32 srcIsFolder,
+    const FILETIME *srcTime, const UInt64 *srcSize,
+    const wchar_t *destPath,
+    BSTR *destPathResult,
+    Int32 *writeAnswer)
+{
+  UString destPathResultTemp = destPath;
+
+  // RINOK(StringToBstr(destPath, destPathResult));
+
+  *destPathResult = 0;
+  *writeAnswer = BoolToInt(false);
+
+  FString destPathSys = us2fs(destPath);
+  bool srcIsFolderSpec = IntToBool(srcIsFolder);
+  CFileInfo destFileInfo;
+  
+  if (destFileInfo.Find(destPathSys))
+  {
+    if (srcIsFolderSpec)
+    {
+      if (!destFileInfo.IsDir())
+      {
+        RINOK(MessageError("Cannot replace file with folder with same name", destPathSys));
+        return E_ABORT;
+      }
+      *writeAnswer = BoolToInt(false);
+      return S_OK;
+    }
+  
+    if (destFileInfo.IsDir())
+    {
+      RINOK(MessageError("Cannot replace folder with file with same name", destPathSys));
+      *writeAnswer = BoolToInt(false);
+      return S_OK;
+    }
+
+    switch (OverwriteMode)
+    {
+      case NExtract::NOverwriteMode::kSkip:
+        return S_OK;
+      case NExtract::NOverwriteMode::kAsk:
+      {
+        Int32 overwriteResult;
+        UString destPathSpec = destPath;
+        int slashPos = destPathSpec.ReverseFind_PathSepar();
+        destPathSpec.DeleteFrom((unsigned)(slashPos + 1));
+        destPathSpec += fs2us(destFileInfo.Name);
+
+        RINOK(AskOverwrite(
+            destPathSpec,
+            &destFileInfo.MTime, &destFileInfo.Size,
+            srcPath,
+            srcTime, srcSize,
+            &overwriteResult));
+        
+        switch (overwriteResult)
+        {
+          case NOverwriteAnswer::kCancel: return E_ABORT;
+          case NOverwriteAnswer::kNo: return S_OK;
+          case NOverwriteAnswer::kNoToAll: OverwriteMode = NExtract::NOverwriteMode::kSkip; return S_OK;
+          case NOverwriteAnswer::kYes: break;
+          case NOverwriteAnswer::kYesToAll: OverwriteMode = NExtract::NOverwriteMode::kOverwrite; break;
+          case NOverwriteAnswer::kAutoRename: OverwriteMode = NExtract::NOverwriteMode::kRename; break;
+          default:
+            return E_FAIL;
+        }
+        break;
+      }
+      default:
+        break;
+    }
+    
+    if (OverwriteMode == NExtract::NOverwriteMode::kRename)
+    {
+      if (!AutoRenamePath(destPathSys))
+      {
+        RINOK(MessageError("Cannot create name for file", destPathSys));
+        return E_ABORT;
+      }
+      destPathResultTemp = fs2us(destPathSys);
+    }
+    else
+    {
+      if (NFind::DoesFileExist_Raw(destPathSys))
+      if (!NDir::DeleteFileAlways(destPathSys))
+      if (GetLastError() != ERROR_FILE_NOT_FOUND)
+      {
+        RINOK(MessageError("Cannot delete output file", destPathSys));
+        return E_ABORT;
+      }
+    }
+  }
+  *writeAnswer = BoolToInt(true);
+  return StringToBstr(destPathResultTemp, destPathResult);
+}
+
+
+STDMETHODIMP CExtractCallbackImp::UseExtractToStream(Int32 *res)
+{
+  *res = BoolToInt(StreamMode);
+  return S_OK;
+}
+
+static HRESULT GetTime(IGetProp *getProp, PROPID propID, FILETIME &ft, bool &ftDefined)
+{
+  ftDefined = false;
+  NCOM::CPropVariant prop;
+  RINOK(getProp->GetProp(propID, &prop));
+  if (prop.vt == VT_FILETIME)
+  {
+    ft = prop.filetime;
+    ftDefined = (ft.dwHighDateTime != 0 || ft.dwLowDateTime != 0);
+  }
+  else if (prop.vt != VT_EMPTY)
+    return E_FAIL;
+  return S_OK;
+}
+
+
+static HRESULT GetItemBoolProp(IGetProp *getProp, PROPID propID, bool &result)
+{
+  NCOM::CPropVariant prop;
+  result = false;
+  RINOK(getProp->GetProp(propID, &prop));
+  if (prop.vt == VT_BOOL)
+    result = VARIANT_BOOLToBool(prop.boolVal);
+  else if (prop.vt != VT_EMPTY)
+    return E_FAIL;
+  return S_OK;
+}
+
+
+STDMETHODIMP CExtractCallbackImp::GetStream7(const wchar_t *name,
+    Int32 isDir,
+    ISequentialOutStream **outStream, Int32 askExtractMode,
+    IGetProp *getProp)
+{
+  COM_TRY_BEGIN
+  *outStream = 0;
+  _newVirtFileWasAdded = false;
+  _hashStreamWasUsed = false;
+  _needUpdateStat = false;
+
+  if (_hashStream)
+    _hashStreamSpec->ReleaseStream();
+
+  GetItemBoolProp(getProp, kpidIsAltStream, _isAltStream);
+
+  if (!ProcessAltStreams && _isAltStream)
+    return S_OK;
+
+  _filePath = name;
+  _isFolder = IntToBool(isDir);
+  _curSize = 0;
+  _curSizeDefined = false;
+
+  UInt64 size = 0;
+  bool sizeDefined;
+  {
+    NCOM::CPropVariant prop;
+    RINOK(getProp->GetProp(kpidSize, &prop));
+    sizeDefined = ConvertPropVariantToUInt64(prop, size);
+  }
+
+  if (sizeDefined)
+  {
+    _curSize = size;
+    _curSizeDefined = true;
+  }
+
+  if (askExtractMode != NArchive::NExtract::NAskMode::kExtract &&
+      askExtractMode != NArchive::NExtract::NAskMode::kTest)
+    return S_OK;
+
+  _needUpdateStat = true;
+  
+  CMyComPtr<ISequentialOutStream> outStreamLoc;
+  
+  if (VirtFileSystem && askExtractMode == NArchive::NExtract::NAskMode::kExtract)
+  {
+    CVirtFile &file = VirtFileSystemSpec->AddNewFile();
+    _newVirtFileWasAdded = true;
+    file.Name = name;
+    file.IsDir = IntToBool(isDir);
+    file.IsAltStream = _isAltStream;
+    file.Size = 0;
+
+    RINOK(GetTime(getProp, kpidCTime, file.CTime, file.CTimeDefined));
+    RINOK(GetTime(getProp, kpidATime, file.ATime, file.ATimeDefined));
+    RINOK(GetTime(getProp, kpidMTime, file.MTime, file.MTimeDefined));
+
+    NCOM::CPropVariant prop;
+    RINOK(getProp->GetProp(kpidAttrib, &prop));
+    if (prop.vt == VT_UI4)
+    {
+      file.Attrib = prop.ulVal;
+      file.AttribDefined = true;
+    }
+    // else if (isDir) file.Attrib = FILE_ATTRIBUTE_DIRECTORY;
+
+    file.ExpectedSize = 0;
+    if (sizeDefined)
+      file.ExpectedSize = size;
+    outStreamLoc = VirtFileSystem;
+  }
+
+  if (_hashStream)
+  {
+    {
+      _hashStreamSpec->SetStream(outStreamLoc);
+      outStreamLoc = _hashStream;
+      _hashStreamSpec->Init(true);
+      _hashStreamWasUsed = true;
+    }
+  }
+
+  if (outStreamLoc)
+    *outStream = outStreamLoc.Detach();
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CExtractCallbackImp::PrepareOperation7(Int32 askExtractMode)
+{
+  COM_TRY_BEGIN
+  _needUpdateStat = (
+         askExtractMode == NArchive::NExtract::NAskMode::kExtract
+      || askExtractMode == NArchive::NExtract::NAskMode::kTest
+      || askExtractMode == NArchive::NExtract::NAskMode::kReadExternal
+      );
+
+  /*
+  _extractMode = false;
+  switch (askExtractMode)
+  {
+    case NArchive::NExtract::NAskMode::kExtract:
+      if (_testMode)
+        askExtractMode = NArchive::NExtract::NAskMode::kTest;
+      else
+        _extractMode = true;
+      break;
+  };
+  */
+  return SetCurrentFilePath2(_filePath);
+  COM_TRY_END
+}
+
+STDMETHODIMP CExtractCallbackImp::SetOperationResult8(Int32 opRes, Int32 encrypted, UInt64 size)
+{
+  COM_TRY_BEGIN
+  if (VirtFileSystem && _newVirtFileWasAdded)
+  {
+    // FIXME: probably we must request file size from VirtFileSystem
+    // _curSize = VirtFileSystem->GetLastFileSize()
+    // _curSizeDefined = true;
+    RINOK(VirtFileSystemSpec->CloseMemFile());
+  }
+  if (_hashStream && _hashStreamWasUsed)
+  {
+    _hashStreamSpec->_hash->Final(_isFolder, _isAltStream, _filePath);
+    _curSize = _hashStreamSpec->GetSize();
+    _curSizeDefined = true;
+    _hashStreamSpec->ReleaseStream();
+    _hashStreamWasUsed = false;
+  }
+  else if (_hashCalc && _needUpdateStat)
+  {
+    _hashCalc->SetSize(size); // (_curSize) before 21.04
+    _hashCalc->Final(_isFolder, _isAltStream, _filePath);
+  }
+  return SetOperationResult(opRes, encrypted);
+  COM_TRY_END
+}
+
+
+
+// static const UInt32 kBlockSize = ((UInt32)1 << 31);
+
+STDMETHODIMP CVirtFileSystem::Write(const void *data, UInt32 size, UInt32 *processedSize)
+{
+  if (processedSize)
+    *processedSize = 0;
+  if (size == 0)
+    return S_OK;
+  if (!_fileMode)
+  {
+    CVirtFile &file = Files.Back();
+    size_t rem = file.Data.Size() - (size_t)file.Size;
+    bool useMem = true;
+    if (rem < size)
+    {
+      UInt64 b = 0;
+      if (file.Data.Size() == 0)
+        b = file.ExpectedSize;
+      UInt64 a = file.Size + size;
+      if (b < a)
+        b = a;
+      a = (UInt64)file.Data.Size() * 2;
+      if (b < a)
+        b = a;
+      useMem = false;
+      const size_t b_sizet = (size_t)b;
+      if (b == b_sizet && b <= MaxTotalAllocSize)
+        useMem = file.Data.ReAlloc_KeepData(b_sizet, (size_t)file.Size);
+    }
+    if (useMem)
+    {
+      memcpy(file.Data + file.Size, data, size);
+      file.Size += size;
+      if (processedSize)
+        *processedSize = (UInt32)size;
+      return S_OK;
+    }
+    _fileMode = true;
+  }
+  RINOK(FlushToDisk(false));
+  return _outFileStream->Write(data, size, processedSize);
+}
+
+HRESULT CVirtFileSystem::FlushToDisk(bool closeLast)
+{
+  if (!_outFileStream)
+  {
+    _outFileStreamSpec = new COutFileStream;
+    _outFileStream = _outFileStreamSpec;
+  }
+  while (_numFlushed < Files.Size())
+  {
+    const CVirtFile &file = Files[_numFlushed];
+    const FString path = DirPrefix + us2fs(Get_Correct_FsFile_Name(file.Name));
+    if (!_fileIsOpen)
+    {
+      if (!_outFileStreamSpec->Create(path, false))
+      {
+        _outFileStream.Release();
+        return E_FAIL;
+        // MessageBoxMyError(UString("Can't create file ") + fs2us(tempFilePath));
+      }
+      _fileIsOpen = true;
+      RINOK(WriteStream(_outFileStream, file.Data, (size_t)file.Size));
+    }
+    if (_numFlushed == Files.Size() - 1 && !closeLast)
+      break;
+    if (file.CTimeDefined ||
+        file.ATimeDefined ||
+        file.MTimeDefined)
+      _outFileStreamSpec->SetTime(
+          file.CTimeDefined ? &file.CTime : NULL,
+          file.ATimeDefined ? &file.ATime : NULL,
+          file.MTimeDefined ? &file.MTime : NULL);
+    _outFileStreamSpec->Close();
+    _numFlushed++;
+    _fileIsOpen = false;
+    if (file.AttribDefined)
+      NDir::SetFileAttrib_PosixHighDetect(path, file.Attrib);
+  }
+  return S_OK;
+}
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/ExtractCallback.h b/CPP/7zip/UI/FileManager/ExtractCallback.h
new file mode 100644
index 0000000..02578bb
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ExtractCallback.h
@@ -0,0 +1,327 @@
+// ExtractCallback.h
+
+#ifndef __EXTRACT_CALLBACK_H
+#define __EXTRACT_CALLBACK_H
+
+#include "../../../../C/Alloc.h"
+
+#include "../../../Common/MyCom.h"
+#include "../../../Common/StringConvert.h"
+
+#ifndef _SFX
+#include "../Agent/IFolderArchive.h"
+#endif
+
+#include "../Common/ArchiveExtractCallback.h"
+#include "../Common/ArchiveOpenCallback.h"
+
+#ifndef _NO_CRYPTO
+#include "../../IPassword.h"
+#endif
+
+#ifndef _SFX
+#include "IFolder.h"
+#endif
+
+#include "ProgressDialog2.h"
+
+#ifdef LANG
+#include "LangUtils.h"
+#endif
+
+#ifndef _SFX
+
+class CGrowBuf
+{
+  Byte *_items;
+  size_t _size;
+
+  CLASS_NO_COPY(CGrowBuf);
+
+public:
+  bool ReAlloc_KeepData(size_t newSize, size_t keepSize)
+  {
+    void *buf = MyAlloc(newSize);
+    if (!buf)
+      return false;
+    if (keepSize != 0)
+      memcpy(buf, _items, keepSize);
+    MyFree(_items);
+    _items = (Byte *)buf;
+    _size = newSize;
+    return true;
+  }
+
+  CGrowBuf(): _items(0), _size(0) {}
+  ~CGrowBuf() { MyFree(_items); }
+
+  operator Byte *() { return _items; }
+  operator const Byte *() const { return _items; }
+  size_t Size() const { return _size; }
+};
+
+struct CVirtFile
+{
+  CGrowBuf Data;
+  
+  UInt64 Size; // real size
+  UInt64 ExpectedSize; // the size from props request. 0 if unknown
+
+  UString Name;
+
+  bool CTimeDefined;
+  bool ATimeDefined;
+  bool MTimeDefined;
+  bool AttribDefined;
+  
+  bool IsDir;
+  bool IsAltStream;
+  
+  DWORD Attrib;
+
+  FILETIME CTime;
+  FILETIME ATime;
+  FILETIME MTime;
+
+  CVirtFile():
+    CTimeDefined(false),
+    ATimeDefined(false),
+    MTimeDefined(false),
+    AttribDefined(false),
+    IsDir(false),
+    IsAltStream(false) {}
+};
+
+class CVirtFileSystem:
+  public ISequentialOutStream,
+  public CMyUnknownImp
+{
+  UInt64 _totalAllocSize;
+
+  size_t _pos;
+  unsigned _numFlushed;
+  bool _fileIsOpen;
+  bool _fileMode;
+  COutFileStream *_outFileStreamSpec;
+  CMyComPtr<ISequentialOutStream> _outFileStream;
+public:
+  CObjectVector<CVirtFile> Files;
+  UInt64 MaxTotalAllocSize;
+  FString DirPrefix;
+ 
+  CVirtFile &AddNewFile()
+  {
+    if (!Files.IsEmpty())
+    {
+      MaxTotalAllocSize -= Files.Back().Data.Size();
+    }
+    return Files.AddNew();
+  }
+  HRESULT CloseMemFile()
+  {
+    if (_fileMode)
+    {
+      return FlushToDisk(true);
+    }
+    CVirtFile &file = Files.Back();
+    if (file.Data.Size() != file.Size)
+    {
+      file.Data.ReAlloc_KeepData((size_t)file.Size, (size_t)file.Size);
+    }
+    return S_OK;
+  }
+
+  bool IsStreamInMem() const
+  {
+    if (_fileMode)
+      return false;
+    if (Files.Size() < 1 || /* Files[0].IsAltStream || */ Files[0].IsDir)
+      return false;
+    return true;
+  }
+
+  size_t GetMemStreamWrittenSize() const { return _pos; }
+
+  CVirtFileSystem(): _outFileStreamSpec(NULL), MaxTotalAllocSize((UInt64)0 - 1) {}
+
+  void Init()
+  {
+    _totalAllocSize = 0;
+    _fileMode = false;
+    _pos = 0;
+    _numFlushed = 0;
+    _fileIsOpen = false;
+  }
+
+  HRESULT CloseFile(const FString &path);
+  HRESULT FlushToDisk(bool closeLast);
+  size_t GetPos() const { return _pos; }
+
+  MY_UNKNOWN_IMP
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+};
+
+#endif
+  
+class CExtractCallbackImp:
+  public IExtractCallbackUI, // it includes IFolderArchiveExtractCallback
+  public IOpenCallbackUI,
+  public IFolderArchiveExtractCallback2,
+  #ifndef _SFX
+  public IFolderOperationsExtractCallback,
+  public IFolderExtractToStreamCallback,
+  public ICompressProgressInfo,
+  #endif
+  #ifndef _NO_CRYPTO
+  public ICryptoGetTextPassword,
+  #endif
+  public CMyUnknownImp
+{
+  HRESULT MessageError(const char *message, const FString &path);
+  void Add_ArchiveName_Error();
+public:
+  MY_QUERYINTERFACE_BEGIN2(IFolderArchiveExtractCallback)
+  MY_QUERYINTERFACE_ENTRY(IFolderArchiveExtractCallback2)
+  #ifndef _SFX
+  MY_QUERYINTERFACE_ENTRY(IFolderOperationsExtractCallback)
+  MY_QUERYINTERFACE_ENTRY(IFolderExtractToStreamCallback)
+  MY_QUERYINTERFACE_ENTRY(ICompressProgressInfo)
+  #endif
+  #ifndef _NO_CRYPTO
+  MY_QUERYINTERFACE_ENTRY(ICryptoGetTextPassword)
+  #endif
+  MY_QUERYINTERFACE_END
+  MY_ADDREF_RELEASE
+
+  INTERFACE_IProgress(;)
+  INTERFACE_IOpenCallbackUI(;)
+  INTERFACE_IFolderArchiveExtractCallback(;)
+  INTERFACE_IFolderArchiveExtractCallback2(;)
+  // STDMETHOD(SetTotalFiles)(UInt64 total);
+  // STDMETHOD(SetCompletedFiles)(const UInt64 *value);
+
+  INTERFACE_IExtractCallbackUI(;)
+
+  #ifndef _SFX
+  // IFolderOperationsExtractCallback
+  STDMETHOD(AskWrite)(
+      const wchar_t *srcPath,
+      Int32 srcIsFolder,
+      const FILETIME *srcTime,
+      const UInt64 *srcSize,
+      const wchar_t *destPathRequest,
+      BSTR *destPathResult,
+      Int32 *writeAnswer);
+  STDMETHOD(ShowMessage)(const wchar_t *message);
+  STDMETHOD(SetCurrentFilePath)(const wchar_t *filePath);
+  STDMETHOD(SetNumFiles)(UInt64 numFiles);
+  INTERFACE_IFolderExtractToStreamCallback(;)
+  STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
+  #endif
+
+  // ICryptoGetTextPassword
+  #ifndef _NO_CRYPTO
+  STDMETHOD(CryptoGetTextPassword)(BSTR *password);
+  #endif
+
+private:
+  UString _currentArchivePath;
+  bool _needWriteArchivePath;
+
+  UString _currentFilePath;
+  bool _isFolder;
+
+  bool _isAltStream;
+  UInt64 _curSize;
+  bool _curSizeDefined;
+  UString _filePath;
+  // bool _extractMode;
+  // bool _testMode;
+  bool _newVirtFileWasAdded;
+  bool _needUpdateStat;
+
+
+  HRESULT SetCurrentFilePath2(const wchar_t *filePath);
+  void AddError_Message(LPCWSTR message);
+
+  #ifndef _SFX
+  bool _hashStreamWasUsed;
+  COutStreamWithHash *_hashStreamSpec;
+  CMyComPtr<ISequentialOutStream> _hashStream;
+  IHashCalc *_hashCalc; // it's for stat in Test operation
+  #endif
+
+public:
+
+  #ifndef _SFX
+  CVirtFileSystem *VirtFileSystemSpec;
+  CMyComPtr<ISequentialOutStream> VirtFileSystem;
+  #endif
+
+  bool ProcessAltStreams;
+
+  bool StreamMode;
+
+  CProgressDialog *ProgressDialog;
+  #ifndef _SFX
+  UInt64 NumFolders;
+  UInt64 NumFiles;
+  bool NeedAddFile;
+  #endif
+  UInt32 NumArchiveErrors;
+  bool ThereAreMessageErrors;
+  NExtract::NOverwriteMode::EEnum OverwriteMode;
+
+  #ifndef _NO_CRYPTO
+  bool PasswordIsDefined;
+  bool PasswordWasAsked;
+  UString Password;
+  #endif
+
+
+  UString _lang_Extracting;
+  UString _lang_Testing;
+  UString _lang_Skipping;
+  UString _lang_Reading;
+  UString _lang_Empty;
+
+  bool _totalFilesDefined;
+  bool _totalBytesDefined;
+  bool MultiArcMode;
+
+  CExtractCallbackImp():
+    #ifndef _SFX
+    _hashCalc(NULL),
+    #endif
+    ProcessAltStreams(true),
+    StreamMode(false),
+    OverwriteMode(NExtract::NOverwriteMode::kAsk),
+    #ifndef _NO_CRYPTO
+    PasswordIsDefined(false),
+    PasswordWasAsked(false),
+    #endif
+    _totalFilesDefined(false),
+    _totalBytesDefined(false),
+    MultiArcMode(false)
+    {}
+   
+  ~CExtractCallbackImp();
+  void Init();
+
+  #ifndef _SFX
+  void SetHashCalc(IHashCalc *hashCalc) { _hashCalc = hashCalc; }
+
+  void SetHashMethods(IHashCalc *hash)
+  {
+    if (!hash)
+      return;
+    _hashStreamSpec = new COutStreamWithHash;
+    _hashStream = _hashStreamSpec;
+    _hashStreamSpec->_hash = hash;
+  }
+  #endif
+
+  bool IsOK() const { return NumArchiveErrors == 0 && !ThereAreMessageErrors; }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/FM.cpp b/CPP/7zip/UI/FileManager/FM.cpp
new file mode 100644
index 0000000..812eff6
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FM.cpp
@@ -0,0 +1,1093 @@
+// FM.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyWindows.h"
+
+#include <Shlwapi.h>
+
+#include "../../../../C/Alloc.h"
+#ifdef _WIN32
+#include "../../../../C/DllSecur.h"
+#endif
+
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/StringToInt.h"
+
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/MemoryLock.h"
+#include "../../../Windows/NtCheck.h"
+#include "../../../Windows/System.h"
+
+#ifndef UNDER_CE
+#include "../../../Windows/SecurityUtils.h"
+#endif
+
+#include "../GUI/ExtractRes.h"
+
+#include "resource.h"
+
+#include "App.h"
+#include "FormatUtils.h"
+#include "LangUtils.h"
+#include "MyLoadMenu.h"
+#include "Panel.h"
+#include "RegistryUtils.h"
+#include "StringUtils.h"
+#include "ViewSettings.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NFind;
+
+// #define MAX_LOADSTRING 100
+
+extern
+bool g_RAM_Size_Defined;
+bool g_RAM_Size_Defined;
+
+static bool g_LargePagesMode = false;
+// static bool g_OpenArchive = false;
+
+static bool g_Maximized = false;
+
+extern
+UInt64 g_RAM_Size;
+UInt64 g_RAM_Size;
+
+#ifdef _WIN32
+extern
+HINSTANCE g_hInstance;
+HINSTANCE g_hInstance;
+#endif
+
+HWND g_HWND;
+
+static UString g_MainPath;
+static UString g_ArcFormat;
+
+// HRESULT LoadGlobalCodecs();
+void FreeGlobalCodecs();
+
+#ifndef UNDER_CE
+
+extern
+DWORD g_ComCtl32Version;
+DWORD g_ComCtl32Version;
+
+static DWORD GetDllVersion(LPCTSTR dllName)
+{
+  DWORD dwVersion = 0;
+  HINSTANCE hinstDll = LoadLibrary(dllName);
+  if (hinstDll)
+  {
+    DLLGETVERSIONPROC pDllGetVersion = (DLLGETVERSIONPROC)(void *)GetProcAddress(hinstDll, "DllGetVersion");
+    if (pDllGetVersion)
+    {
+      DLLVERSIONINFO dvi;
+      ZeroMemory(&dvi, sizeof(dvi));
+      dvi.cbSize = sizeof(dvi);
+      HRESULT hr = (*pDllGetVersion)(&dvi);
+      if (SUCCEEDED(hr))
+        dwVersion = MAKELONG(dvi.dwMinorVersion, dvi.dwMajorVersion);
+    }
+    FreeLibrary(hinstDll);
+  }
+  return dwVersion;
+}
+
+#endif
+
+bool g_IsSmallScreen = false;
+
+extern
+bool g_LVN_ITEMACTIVATE_Support;
+bool g_LVN_ITEMACTIVATE_Support = true;
+// LVN_ITEMACTIVATE replaces both NM_DBLCLK & NM_RETURN
+// Windows 2000
+// NT/98 + IE 3 (g_ComCtl32Version >= 4.70)
+
+
+static const int kNumDefaultPanels = 1;
+static const int kSplitterWidth = 4;
+static const int kSplitterRateMax = 1 << 16;
+static const int kPanelSizeMin = 120;
+
+
+class CSplitterPos
+{
+  int _ratio; // 10000 is max
+  int _pos;
+  int _fullWidth;
+  void SetRatioFromPos(HWND hWnd)
+    { _ratio = (_pos + kSplitterWidth / 2) * kSplitterRateMax /
+        MyMax(GetWidth(hWnd), 1); }
+public:
+  int GetPos() const
+    { return _pos; }
+  int GetWidth(HWND hWnd) const
+  {
+    RECT rect;
+    ::GetClientRect(hWnd, &rect);
+    return rect.right;
+  }
+  void SetRatio(HWND hWnd, int aRatio)
+  {
+    _ratio = aRatio;
+    SetPosFromRatio(hWnd);
+  }
+  void SetPosPure(HWND hWnd, int pos)
+  {
+    int posMax = GetWidth(hWnd) - kSplitterWidth;
+    if (posMax < kPanelSizeMin * 2)
+      pos = posMax / 2;
+    else
+    {
+      if (pos > posMax - kPanelSizeMin)
+        pos = posMax - kPanelSizeMin;
+      else if (pos < kPanelSizeMin)
+        pos = kPanelSizeMin;
+    }
+    _pos = pos;
+  }
+  void SetPos(HWND hWnd, int pos)
+  {
+    _fullWidth = GetWidth(hWnd);
+    SetPosPure(hWnd, pos);
+    SetRatioFromPos(hWnd);
+  }
+  void SetPosFromRatio(HWND hWnd)
+  {
+    int fullWidth = GetWidth(hWnd);
+    if (_fullWidth != fullWidth && fullWidth != 0)
+    {
+      _fullWidth = fullWidth;
+      SetPosPure(hWnd, GetWidth(hWnd) * _ratio / kSplitterRateMax - kSplitterWidth / 2);
+    }
+  }
+};
+
+static bool g_CanChangeSplitter = false;
+static UInt32 g_SplitterPos = 0;
+static CSplitterPos g_Splitter;
+static bool g_PanelsInfoDefined = false;
+static bool g_WindowWasCreated = false;
+
+static int g_StartCaptureMousePos;
+static int g_StartCaptureSplitterPos;
+
+CApp g_App;
+
+LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
+
+static const wchar_t * const kWindowClass = L"FM";
+
+#ifdef UNDER_CE
+#define WS_OVERLAPPEDWINDOW ( \
+  WS_OVERLAPPED   | \
+  WS_CAPTION      | \
+  WS_SYSMENU      | \
+  WS_THICKFRAME   | \
+  WS_MINIMIZEBOX  | \
+  WS_MAXIMIZEBOX)
+#endif
+
+//  FUNCTION: InitInstance(HANDLE, int)
+static BOOL InitInstance(int nCmdShow)
+{
+  CWindow wnd;
+
+  // LoadString(hInstance, IDS_CLASS, windowClass, MAX_LOADSTRING);
+
+  UString title ("7-Zip"); // LangString(IDS_APP_TITLE, 0x03000000);
+
+  /*
+  //If it is already running, then focus on the window
+  hWnd = FindWindow(windowClass, title);
+  if (hWnd)
+  {
+    SetForegroundWindow ((HWND) (((DWORD)hWnd) | 0x01));
+    return 0;
+  }
+  */
+
+  WNDCLASSW wc;
+
+  // wc.style = CS_HREDRAW | CS_VREDRAW;
+  wc.style = 0;
+  wc.lpfnWndProc = (WNDPROC) WndProc;
+  wc.cbClsExtra = 0;
+  wc.cbWndExtra = 0;
+  wc.hInstance = g_hInstance;
+  wc.hIcon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_ICON));
+
+  // wc.hCursor = LoadCursor (NULL, IDC_ARROW);
+  wc.hCursor = ::LoadCursor(0, IDC_SIZEWE);
+  // wc.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
+  wc.hbrBackground = (HBRUSH) (COLOR_BTNFACE + 1);
+
+  wc.lpszMenuName =
+    #ifdef UNDER_CE
+    0
+    #else
+    MAKEINTRESOURCEW(IDM_MENU)
+    #endif
+    ;
+
+  wc.lpszClassName = kWindowClass;
+
+  MyRegisterClass(&wc);
+
+  // RECT rect;
+  // GetClientRect(hWnd, &rect);
+
+  DWORD style = WS_OVERLAPPEDWINDOW;
+  // DWORD style = 0;
+  
+  CWindowInfo info;
+  info.maximized = false;
+  int x, y, xSize, ySize;
+  x = y = xSize = ySize = CW_USEDEFAULT;
+  bool windowPosIsRead;
+  info.Read(windowPosIsRead, g_PanelsInfoDefined);
+
+  if (windowPosIsRead)
+  {
+    x = info.rect.left;
+    y = info.rect.top;
+    
+    xSize = RECT_SIZE_X(info.rect);
+    ySize = RECT_SIZE_Y(info.rect);
+  }
+
+
+  if (g_PanelsInfoDefined)
+  {
+    g_SplitterPos = info.splitterPos;
+    if (info.numPanels < 1 || info.numPanels > 2)
+      info.numPanels = kNumDefaultPanels;
+    if (info.currentPanel >= 2)
+      info.currentPanel = 0;
+  }
+  else
+  {
+    info.numPanels = kNumDefaultPanels;
+    info.currentPanel = 0;
+  }
+
+  g_App.NumPanels = info.numPanels;
+  g_App.LastFocusedPanel = info.currentPanel;
+
+  if (!wnd.Create(kWindowClass, title, style,
+    x, y, xSize, ySize, NULL, NULL, g_hInstance, NULL))
+    return FALSE;
+
+  if (nCmdShow == SW_SHOWNORMAL ||
+      nCmdShow == SW_SHOW
+      #ifndef UNDER_CE
+      || nCmdShow == SW_SHOWDEFAULT
+      #endif
+      )
+  {
+    if (info.maximized)
+      nCmdShow = SW_SHOWMAXIMIZED;
+    else
+      nCmdShow = SW_SHOWNORMAL;
+  }
+
+  if (nCmdShow == SW_SHOWMAXIMIZED)
+    g_Maximized = true;
+
+  #ifndef UNDER_CE
+  WINDOWPLACEMENT placement;
+  placement.length = sizeof(placement);
+  if (wnd.GetPlacement(&placement))
+  {
+    if (windowPosIsRead)
+      placement.rcNormalPosition = info.rect;
+    placement.showCmd = nCmdShow;
+    wnd.SetPlacement(&placement);
+  }
+  else
+  #endif
+    wnd.Show(nCmdShow);
+
+  return TRUE;
+}
+
+/*
+static void GetCommands(const UString &aCommandLine, UString &aCommands)
+{
+  UString aProgramName;
+  aCommands.Empty();
+  bool aQuoteMode = false;
+  for (int i = 0; i < aCommandLine.Length(); i++)
+  {
+    wchar_t aChar = aCommandLine[i];
+    if (aChar == L'\"')
+      aQuoteMode = !aQuoteMode;
+    else if (aChar == L' ' && !aQuoteMode)
+    {
+      if (!aQuoteMode)
+      {
+        i++;
+        break;
+      }
+    }
+    else
+      aProgramName += aChar;
+  }
+  aCommands = aCommandLine.Ptr(i);
+}
+*/
+
+#if defined(_WIN32) && !defined(_WIN64) && !defined(UNDER_CE)
+
+bool g_Is_Wow64;
+
+typedef BOOL (WINAPI *Func_IsWow64Process)(HANDLE, PBOOL);
+
+static void Set_Wow64()
+{
+  g_Is_Wow64 = false;
+  Func_IsWow64Process fnIsWow64Process = (Func_IsWow64Process)(void *)GetProcAddress(
+      GetModuleHandleA("kernel32.dll"), "IsWow64Process");
+  if (fnIsWow64Process)
+  {
+    BOOL isWow;
+    if (fnIsWow64Process(GetCurrentProcess(), &isWow))
+      g_Is_Wow64 = (isWow != FALSE);
+  }
+}
+
+#endif
+
+
+bool IsLargePageSupported();
+bool IsLargePageSupported()
+{
+  #ifdef _WIN64
+  return true;
+  #else
+  OSVERSIONINFO vi;
+  vi.dwOSVersionInfoSize = sizeof(vi);
+  if (!::GetVersionEx(&vi))
+    return false;
+  if (vi.dwPlatformId != VER_PLATFORM_WIN32_NT)
+    return false;
+  if (vi.dwMajorVersion < 5) return false;
+  if (vi.dwMajorVersion > 5) return true;
+  if (vi.dwMinorVersion < 1) return false;
+  if (vi.dwMinorVersion > 1) return true;
+  // return g_Is_Wow64;
+  return false;
+  #endif
+}
+
+#ifndef UNDER_CE
+
+static void SetMemoryLock()
+{
+  if (!IsLargePageSupported())
+    return;
+  // if (ReadLockMemoryAdd())
+  NSecurity::AddLockMemoryPrivilege();
+
+  if (ReadLockMemoryEnable())
+  if (NSecurity::Get_LargePages_RiskLevel() == 0)
+  {
+    // note: child processes can inherit that Privilege
+    g_LargePagesMode = NSecurity::EnablePrivilege_LockMemory();
+  }
+}
+
+extern
+bool g_SymLink_Supported;
+bool g_SymLink_Supported = false;
+
+static void Set_SymLink_Supported()
+{
+  g_SymLink_Supported = false;
+  OSVERSIONINFO vi;
+  vi.dwOSVersionInfoSize = sizeof(vi);
+  if (!::GetVersionEx(&vi))
+    return;
+  if (vi.dwPlatformId != VER_PLATFORM_WIN32_NT || vi.dwMajorVersion < 6)
+    return;
+  g_SymLink_Supported = true;
+  // if (g_SymLink_Supported)
+  {
+    NSecurity::EnablePrivilege_SymLink();
+  }
+}
+
+#endif
+
+/*
+static const int kNumSwitches = 1;
+
+namespace NKey {
+enum Enum
+{
+  kOpenArachive = 0
+};
+
+}
+
+static const CSwitchForm kSwitchForms[kNumSwitches] =
+  {
+    { L"SOA", NSwitchType::kSimple, false },
+  };
+*/
+
+// int APIENTRY WinMain2(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */, LPSTR /* lpCmdLine */, int /* nCmdShow */);
+
+static void ErrorMessage(const wchar_t *s)
+{
+  MessageBoxW(0, s, L"7-Zip", MB_ICONERROR);
+}
+
+static void ErrorMessage(const char *s)
+{
+  ErrorMessage(GetUnicodeString(s));
+}
+
+
+#if defined(_UNICODE) && !defined(_WIN64) && !defined(UNDER_CE)
+#define NT_CHECK_FAIL_ACTION ErrorMessage("Unsupported Windows version"); return 1;
+#endif
+
+static int WINAPI WinMain2(int nCmdShow)
+{
+  g_RAM_Size_Defined = NSystem::GetRamSize(g_RAM_Size);
+
+  #ifdef _WIN32
+
+  /*
+  #ifndef _WIN64
+  #ifndef UNDER_CE
+  {
+    HMODULE hMod = GetModuleHandle("Kernel32.dll");
+    if (hMod)
+    {
+      typedef BOOL (WINAPI *PSETDEP)(DWORD);
+      #define MY_PROCESS_DEP_ENABLE 1
+      PSETDEP procSet = (PSETDEP)GetProcAddress(hMod,"SetProcessDEPPolicy");
+      if (procSet)
+        procSet(MY_PROCESS_DEP_ENABLE);
+
+      typedef BOOL (WINAPI *HSI)(HANDLE, HEAP_INFORMATION_CLASS ,PVOID, SIZE_T);
+      HSI hsi = (HSI)GetProcAddress(hMod, "HeapSetInformation");
+      #define MY_HeapEnableTerminationOnCorruption ((HEAP_INFORMATION_CLASS)1)
+      if (hsi)
+        hsi(NULL, MY_HeapEnableTerminationOnCorruption, NULL, 0);
+    }
+  }
+  #endif
+  #endif
+  */
+
+  NT_CHECK
+  SetLargePageSize();
+
+  #endif
+
+  LoadLangOneTime();
+
+  InitCommonControls();
+
+  #ifndef UNDER_CE
+  g_ComCtl32Version = ::GetDllVersion(TEXT("comctl32.dll"));
+  g_LVN_ITEMACTIVATE_Support = (g_ComCtl32Version >= MAKELONG(71, 4));
+  #endif
+
+  #if defined(_WIN32) && !defined(_WIN64) && !defined(UNDER_CE)
+  Set_Wow64();
+  #endif
+
+
+  g_IsSmallScreen = !NWindows::NControl::IsDialogSizeOK(200, 200);
+
+  // OleInitialize is required for drag and drop.
+  #ifndef UNDER_CE
+  OleInitialize(NULL);
+  #endif
+  // Maybe needs CoInitializeEx also ?
+  // NCOM::CComInitializer comInitializer;
+
+  UString commandsString;
+  // MessageBoxW(0, GetCommandLineW(), L"", 0);
+
+  #ifdef UNDER_CE
+  commandsString = GetCommandLineW();
+  #else
+  UString programString;
+  SplitStringToTwoStrings(GetCommandLineW(), programString, commandsString);
+  #endif
+
+  commandsString.Trim();
+  UString paramString, tailString;
+  SplitStringToTwoStrings(commandsString, paramString, tailString);
+  paramString.Trim();
+  tailString.Trim();
+  if (tailString.IsPrefixedBy(L"-t"))
+    g_ArcFormat = tailString.Ptr(2);
+
+  /*
+  UStringVector switches;
+  for (;;)
+  {
+    if (tailString.IsEmpty())
+      break;
+    UString s1, s2;
+    SplitStringToTwoStrings(tailString, s1, s2);
+    if (s2.IsEmpty())
+    {
+      tailString.Trim();
+      switches.Add(tailString);
+      break;
+    }
+    s1.Trim();
+    switches.Add(s1);
+    tailString = s2;
+  }
+
+  FOR_VECTOR(i, switches)
+  {
+    const UString &sw = switches[i];
+    if (sw.IsPrefixedBy(L"-t"))
+      g_ArcFormat = sw.Ptr(2);
+    //
+    else if (sw.IsPrefixedBy(L"-stp"))
+    {
+      const wchar_t *end;
+      UInt32 val = ConvertStringToUInt32(sw.Ptr(4), &end);
+      if (*end != 0)
+        throw 111;
+      g_TypeParseLevel = val;
+    }
+    else
+    //
+      throw 112;
+  }
+  */
+
+  if (!paramString.IsEmpty())
+  {
+    g_MainPath = paramString;
+    // return WinMain2(hInstance, hPrevInstance, lpCmdLine, nCmdShow);
+
+    // MessageBoxW(0, paramString, L"", 0);
+  }
+  /*
+  UStringVector commandStrings;
+  NCommandLineParser::SplitCommandLine(GetCommandLineW(), commandStrings);
+  NCommandLineParser::CParser parser(kNumSwitches);
+  try
+  {
+    parser.ParseStrings(kSwitchForms, commandStrings);
+    const UStringVector &nonSwitchStrings = parser.NonSwitchStrings;
+    if (nonSwitchStrings.Size() > 1)
+    {
+      g_MainPath = nonSwitchStrings[1];
+      // g_OpenArchive = parser[NKey::kOpenArachive].ThereIs;
+      CFileInfoW fileInfo;
+      if (FindFile(g_MainPath, fileInfo))
+      {
+        if (!fileInfo.IsDir())
+          g_OpenArchive = true;
+      }
+    }
+  }
+  catch(...) { }
+  */
+
+
+  #if defined(_WIN32) && !defined(UNDER_CE)
+  SetMemoryLock();
+  Set_SymLink_Supported();
+  #endif
+
+  g_App.ReloadLang();
+
+  MSG msg;
+  if (!InitInstance (nCmdShow))
+    return FALSE;
+
+  // we will load Global_Codecs at first use instead.
+  /*
+  OutputDebugStringW(L"Before LoadGlobalCodecs");
+  LoadGlobalCodecs();
+  OutputDebugStringW(L"After LoadGlobalCodecs");
+  */
+
+  #ifndef _UNICODE
+  if (g_IsNT)
+  {
+    HACCEL hAccels = LoadAcceleratorsW(g_hInstance, MAKEINTRESOURCEW(IDR_ACCELERATOR1));
+    while (GetMessageW(&msg, NULL, 0, 0))
+    {
+      if (TranslateAcceleratorW(g_HWND, hAccels, &msg) == 0)
+      {
+        TranslateMessage(&msg);
+        DispatchMessageW(&msg);
+      }
+    }
+  }
+  else
+  #endif
+  {
+    HACCEL hAccels = LoadAccelerators(g_hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR1));
+    while (GetMessage(&msg, NULL, 0, 0))
+    {
+      if (TranslateAccelerator(g_HWND, hAccels, &msg) == 0)
+      {
+        // if (g_Hwnd != NULL || !IsDialogMessage(g_Hwnd, &msg))
+        // if (!IsDialogMessage(g_Hwnd, &msg))
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+      }
+    }
+  }
+
+  // Destructor of g_CodecsReleaser can release DLLs.
+  // But we suppose that it's better to release DLLs here (before destructor).
+  FreeGlobalCodecs();
+
+  g_HWND = 0;
+  #ifndef UNDER_CE
+  OleUninitialize();
+  #endif
+  return (int)msg.wParam;
+}
+
+int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
+    #ifdef UNDER_CE
+    LPWSTR
+    #else
+    LPSTR
+    #endif
+    /* lpCmdLine */, int nCmdShow)
+{
+  g_hInstance = hInstance;
+
+  try
+  {
+    try
+    {
+      #ifdef _WIN32
+      My_SetDefaultDllDirectories();
+      #endif
+      return WinMain2(nCmdShow);
+    }
+    catch (...)
+    {
+      g_ExitEventLauncher.Exit(true);
+      throw;
+    }
+  }
+  catch(const CNewException &)
+  {
+    ErrorMessage(LangString(IDS_MEM_ERROR));
+    return 1;
+  }
+  catch(const UString &s)
+  {
+    ErrorMessage(s);
+    return 1;
+  }
+  catch(const AString &s)
+  {
+    ErrorMessage(s.Ptr());
+    return 1;
+  }
+  catch(const wchar_t *s)
+  {
+    ErrorMessage(s);
+    return 1;
+  }
+  catch(const char *s)
+  {
+    ErrorMessage(s);
+    return 1;
+  }
+  catch(int v)
+  {
+    AString e ("Error: ");
+    e.Add_UInt32(v);
+    ErrorMessage(e);
+    return 1;
+  }
+  catch(...)
+  {
+    ErrorMessage("Unknown error");
+    return 1;
+  }
+}
+
+static void SaveWindowInfo(HWND aWnd)
+{
+  CWindowInfo info;
+
+  #ifdef UNDER_CE
+  
+  if (!::GetWindowRect(aWnd, &info.rect))
+    return;
+  info.maximized = g_Maximized;
+  
+  #else
+  
+  WINDOWPLACEMENT placement;
+  placement.length = sizeof(placement);
+  if (!::GetWindowPlacement(aWnd, &placement))
+    return;
+  info.rect = placement.rcNormalPosition;
+  info.maximized = BOOLToBool(::IsZoomed(aWnd));
+  
+  #endif
+  
+  info.numPanels = g_App.NumPanels;
+  info.currentPanel = g_App.LastFocusedPanel;
+  info.splitterPos = g_Splitter.GetPos();
+
+  info.Save();
+}
+
+static void ExecuteCommand(UINT commandID)
+{
+  CPanel::CDisableTimerProcessing disableTimerProcessing1(g_App.Panels[0]);
+  CPanel::CDisableTimerProcessing disableTimerProcessing2(g_App.Panels[1]);
+
+  switch (commandID)
+  {
+    case kMenuCmdID_Toolbar_Add: g_App.AddToArchive(); break;
+    case kMenuCmdID_Toolbar_Extract: g_App.ExtractArchives(); break;
+    case kMenuCmdID_Toolbar_Test: g_App.TestArchives(); break;
+  }
+}
+
+LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+  switch (message)
+  {
+    case WM_COMMAND:
+    {
+      unsigned wmId    = LOWORD(wParam);
+      unsigned wmEvent = HIWORD(wParam);
+      if ((HWND) lParam != NULL && wmEvent != 0)
+        break;
+      if (wmId >= kMenuCmdID_Toolbar_Start && wmId < kMenuCmdID_Toolbar_End)
+      {
+        ExecuteCommand(wmId);
+        return 0;
+      }
+      if (OnMenuCommand(hWnd, wmId))
+        return 0;
+      break;
+    }
+    case WM_INITMENUPOPUP:
+      OnMenuActivating(hWnd, HMENU(wParam), LOWORD(lParam));
+      break;
+
+    /*
+    It doesn't help
+    case WM_EXITMENULOOP:
+      {
+        OnMenuUnActivating(hWnd);
+        break;
+      }
+    case WM_UNINITMENUPOPUP:
+      OnMenuUnActivating(hWnd, HMENU(wParam), lParam);
+      break;
+    */
+
+    case WM_CREATE:
+    {
+      g_HWND = hWnd;
+      /*
+      INITCOMMONCONTROLSEX icex;
+      icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
+      icex.dwICC  = ICC_BAR_CLASSES;
+      InitCommonControlsEx(&icex);
+      
+      // Toolbar buttons used to create the first 4 buttons.
+      TBBUTTON tbb [ ] =
+      {
+        // {0, 0, TBSTATE_ENABLED, BTNS_SEP, 0L, 0},
+        // {VIEW_PARENTFOLDER, kParentFolderID, TBSTATE_ENABLED, BTNS_BUTTON, 0L, 0},
+          // {0, 0, TBSTATE_ENABLED, BTNS_SEP, 0L, 0},
+        {VIEW_NEWFOLDER, ID_FILE_CREATEFOLDER, TBSTATE_ENABLED, BTNS_BUTTON, 0L, 0},
+      };
+      
+      int baseID = 100;
+      NWindows::NControl::CToolBar aToolBar;
+      aToolBar.Attach(::CreateToolbarEx (hWnd,
+        WS_CHILD | WS_BORDER | WS_VISIBLE | TBSTYLE_TOOLTIPS, //  | TBSTYLE_FLAT
+        baseID + 2, 11,
+        (HINSTANCE)HINST_COMMCTRL, IDB_VIEW_SMALL_COLOR,
+        (LPCTBBUTTON)&tbb, ARRAY_SIZE(tbb),
+        0, 0, 100, 30, sizeof (TBBUTTON)));
+      */
+      // HCURSOR cursor = ::LoadCursor(0, IDC_SIZEWE);
+      // ::SetCursor(cursor);
+
+      if (g_PanelsInfoDefined)
+        g_Splitter.SetPos(hWnd, g_SplitterPos);
+      else
+      {
+        g_Splitter.SetRatio(hWnd, kSplitterRateMax / 2);
+        g_SplitterPos = g_Splitter.GetPos();
+      }
+
+      RECT rect;
+      ::GetClientRect(hWnd, &rect);
+      int xSize = rect.right;
+      int xSizes[2];
+      xSizes[0] = g_Splitter.GetPos();
+      xSizes[1] = xSize - kSplitterWidth - xSizes[0];
+      if (xSizes[1] < 0)
+        xSizes[1] = 0;
+
+      g_App.CreateDragTarget();
+      
+      COpenResult openRes;
+      bool needOpenArc = false;
+
+      UString fullPath = g_MainPath;
+      if (!fullPath.IsEmpty() /* && g_OpenArchive */)
+      {
+        if (!NFile::NName::IsAbsolutePath(fullPath))
+        {
+          FString fullPathF;
+          if (NFile::NName::GetFullPath(us2fs(fullPath), fullPathF))
+            fullPath = fs2us(fullPathF);
+        }
+        if (NFile::NFind::DoesFileExist_FollowLink(us2fs(fullPath)))
+          needOpenArc = true;
+      }
+      
+      HRESULT res = g_App.Create(hWnd, fullPath, g_ArcFormat, xSizes,
+          needOpenArc,
+          openRes);
+
+      if (res == E_ABORT)
+        return -1;
+      
+      if ((needOpenArc && !openRes.ArchiveIsOpened) || res != S_OK)
+      {
+        UString m ("Error");
+        if (res == S_FALSE || res == S_OK)
+        {
+          m = MyFormatNew(openRes.Encrypted ?
+                IDS_CANT_OPEN_ENCRYPTED_ARCHIVE :
+                IDS_CANT_OPEN_ARCHIVE,
+              fullPath);
+        }
+        else if (res != S_OK)
+          m = HResultToMessage(res);
+        if (!openRes.ErrorMessage.IsEmpty())
+        {
+          m.Add_LF();
+          m += openRes.ErrorMessage;
+        }
+        ErrorMessage(m);
+        return -1;
+      }
+
+      g_WindowWasCreated = true;
+      
+      // g_SplitterPos = 0;
+
+      // ::DragAcceptFiles(hWnd, TRUE);
+      RegisterDragDrop(hWnd, g_App._dropTarget);
+
+      break;
+    }
+
+    case WM_DESTROY:
+    {
+      // ::DragAcceptFiles(hWnd, FALSE);
+      RevokeDragDrop(hWnd);
+      g_App._dropTarget.Release();
+
+      if (g_WindowWasCreated)
+        g_App.Save();
+    
+      g_App.Release();
+      
+      if (g_WindowWasCreated)
+        SaveWindowInfo(hWnd);
+
+      g_ExitEventLauncher.Exit(true);
+      PostQuitMessage(0);
+      break;
+    }
+    
+    // case WM_MOVE: break;
+    
+    case WM_LBUTTONDOWN:
+      g_StartCaptureMousePos = LOWORD(lParam);
+      g_StartCaptureSplitterPos = g_Splitter.GetPos();
+      ::SetCapture(hWnd);
+      break;
+    
+    case WM_LBUTTONUP:
+    {
+      ::ReleaseCapture();
+      break;
+    }
+    
+    case WM_MOUSEMOVE:
+    {
+      if ((wParam & MK_LBUTTON) != 0 && ::GetCapture() == hWnd)
+      {
+        g_Splitter.SetPos(hWnd, g_StartCaptureSplitterPos +
+            (short)LOWORD(lParam) - g_StartCaptureMousePos);
+        g_App.MoveSubWindows();
+      }
+      break;
+    }
+
+    case WM_SIZE:
+    {
+      if (g_CanChangeSplitter)
+        g_Splitter.SetPosFromRatio(hWnd);
+      else
+      {
+        g_Splitter.SetPos(hWnd, g_SplitterPos );
+        g_CanChangeSplitter = true;
+      }
+      
+      g_Maximized = (wParam == SIZE_MAXIMIZED) || (wParam == SIZE_MAXSHOW);
+
+      g_App.MoveSubWindows();
+      /*
+      int xSize = LOWORD(lParam);
+      int ySize = HIWORD(lParam);
+      // int xSplitter = 2;
+      int xWidth = g_SplitPos;
+      // int xSplitPos = xWidth;
+      g_Panel[0]._listView.MoveWindow(0, 0, xWidth, ySize);
+      g_Panel[1]._listView.MoveWindow(xSize - xWidth, 0, xWidth, ySize);
+      */
+      return 0;
+      // break;
+    }
+    
+    case WM_SETFOCUS:
+      // g_App.SetFocus(g_App.LastFocusedPanel);
+      g_App.SetFocusToLastItem();
+      break;
+    
+    /*
+    case WM_ACTIVATE:
+    {
+      int fActive = LOWORD(wParam);
+      switch (fActive)
+      {
+        case WA_INACTIVE:
+        {
+          // g_FocusIndex = g_App.LastFocusedPanel;
+          // g_App.LastFocusedPanel = g_App.GetFocusedPanelIndex();
+          // return 0;
+        }
+      }
+      break;
+    }
+    */
+    
+    /*
+    case kLangWasChangedMessage:
+      MyLoadMenu();
+      return 0;
+    */
+      
+    /*
+    case WM_SETTINGCHANGE:
+      break;
+    */
+    
+    case WM_NOTIFY:
+    {
+      g_App.OnNotify((int)wParam, (LPNMHDR)lParam);
+      break;
+    }
+    
+    /*
+    case WM_DROPFILES:
+    {
+      g_App.GetFocusedPanel().CompressDropFiles((HDROP)wParam);
+      return 0 ;
+    }
+    */
+  }
+  #ifndef _UNICODE
+  if (g_IsNT)
+    return DefWindowProcW(hWnd, message, wParam, lParam);
+  else
+  #endif
+    return DefWindowProc(hWnd, message, wParam, lParam);
+
+}
+
+static int Window_GetRealHeight(NWindows::CWindow &w)
+{
+  RECT rect;
+  w.GetWindowRect(&rect);
+  int res = RECT_SIZE_Y(rect);
+  #ifndef UNDER_CE
+  WINDOWPLACEMENT placement;
+  if (w.GetPlacement(&placement))
+    res += placement.rcNormalPosition.top;
+  #endif
+  return res;
+}
+
+void CApp::MoveSubWindows()
+{
+  HWND hWnd = _window;
+  RECT rect;
+  if (hWnd == 0)
+    return;
+  ::GetClientRect(hWnd, &rect);
+  int xSize = rect.right;
+  if (xSize == 0)
+    return;
+  int headerSize = 0;
+
+  #ifdef UNDER_CE
+  _commandBar.AutoSize();
+  {
+    _commandBar.Show(true); // maybe we need it for
+    headerSize += _commandBar.Height();
+  }
+  #endif
+
+  if (_toolBar)
+  {
+    _toolBar.AutoSize();
+    #ifdef UNDER_CE
+    int h2 = Window_GetRealHeight(_toolBar);
+    _toolBar.Move(0, headerSize, xSize, h2);
+    #endif
+    headerSize += Window_GetRealHeight(_toolBar);
+  }
+  
+  int ySize = MyMax((int)(rect.bottom - headerSize), 0);
+  
+  if (NumPanels > 1)
+  {
+    Panels[0].Move(0, headerSize, g_Splitter.GetPos(), ySize);
+    int xWidth1 = g_Splitter.GetPos() + kSplitterWidth;
+    Panels[1].Move(xWidth1, headerSize, xSize - xWidth1, ySize);
+  }
+  else
+  {
+    /*
+    int otherPanel = 1 - LastFocusedPanel;
+    if (PanelsCreated[otherPanel])
+      Panels[otherPanel].Move(0, headerSize, 0, ySize);
+    */
+    Panels[LastFocusedPanel].Move(0, headerSize, xSize, ySize);
+  }
+}
diff --git a/CPP/7zip/UI/FileManager/FM.dsp b/CPP/7zip/UI/FileManager/FM.dsp
new file mode 100644
index 0000000..a12d330
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FM.dsp
@@ -0,0 +1,1643 @@
+# Microsoft Developer Studio Project File - Name="FM" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=FM - Win32 DebugU
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "FM.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "FM.mak" CFG="FM - Win32 DebugU"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "FM - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "FM - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE "FM - Win32 ReleaseU" (based on "Win32 (x86) Application")
+!MESSAGE "FM - Win32 DebugU" (based on "Win32 (x86) Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "FM - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /Gz /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "_MBCS" /D "WIN32" /D "_WINDOWS" /D "LANG" /D "WIN_LONG_PATH" /D "NEW_FOLDER_INTERFACE" /D "EXTERNAL_CODECS" /D "SUPPORT_DEVICE_FILE" /FAcs /Yu"StdAfx.h" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib Mpr.lib htmlhelp.lib Urlmon.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7zFM.exe" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF  "$(CFG)" == "FM - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /Gz /MDd /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "_MBCS" /D "WIN32" /D "_WINDOWS" /D "LANG" /D "WIN_LONG_PATH" /D "NEW_FOLDER_INTERFACE" /D "EXTERNAL_CODECS" /D "SUPPORT_DEVICE_FILE" /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib Mpr.lib htmlhelp.lib Urlmon.lib /nologo /subsystem:windows /debug /machine:I386 /out:"C:\Util\7zFM.exe" /pdbtype:sept
+
+!ELSEIF  "$(CFG)" == "FM - Win32 ReleaseU"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "ReleaseU"
+# PROP BASE Intermediate_Dir "ReleaseU"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "ReleaseU"
+# PROP Intermediate_Dir "ReleaseU"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /Yu"StdAfx.h" /FD /c
+# ADD CPP /nologo /Gz /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "LANG" /D "WIN_LONG_PATH" /D "NEW_FOLDER_INTERFACE" /D "EXTERNAL_CODECS" /D "SUPPORT_DEVICE_FILE" /Yu"StdAfx.h" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib Mpr.lib htmlhelp.lib Urlmon.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7zFM.exe" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF  "$(CFG)" == "FM - Win32 DebugU"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "DebugU"
+# PROP BASE Intermediate_Dir "DebugU"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "DebugU"
+# PROP Intermediate_Dir "DebugU"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /Yu"StdAfx.h" /FD /GZ /c
+# ADD CPP /nologo /Gz /MDd /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "LANG" /D "WIN_LONG_PATH" /D "NEW_FOLDER_INTERFACE" /D "EXTERNAL_CODECS" /D "SUPPORT_DEVICE_FILE" /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib Mpr.lib htmlhelp.lib Urlmon.lib /nologo /subsystem:windows /debug /machine:I386 /out:"C:\Util\7zFM.exe" /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "FM - Win32 Release"
+# Name "FM - Win32 Debug"
+# Name "FM - Win32 ReleaseU"
+# Name "FM - Win32 DebugU"
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\7zipLogo.ico
+# End Source File
+# Begin Source File
+
+SOURCE=.\add.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ClassDefs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Copy.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Delete.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Extract.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\FM.ico
+# End Source File
+# Begin Source File
+
+SOURCE=.\Move.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\MyWindowsNew.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Parent.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Properties.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.rc
+# ADD BASE RSC /l 0x419
+# ADD RSC /l 0x409
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.cpp
+# ADD CPP /Yc"StdAfx.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Test.bmp
+# End Source File
+# End Group
+# Begin Group "Folders"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\AltStreamsFolder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\AltStreamsFolder.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\FSDrives.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\FSDrives.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\FSFolder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\FSFolder.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\FSFolderCopy.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\IFolder.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\NetFolder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\NetFolder.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\RootFolder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RootFolder.h
+# End Source File
+# End Group
+# Begin Group "Registry"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\RegistryAssociations.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RegistryAssociations.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\RegistryPlugins.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RegistryPlugins.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\RegistryUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RegistryUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ViewSettings.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ViewSettings.h
+# End Source File
+# End Group
+# Begin Group "Panel"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\App.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\App.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\AppState.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\EnumFormatEtc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\EnumFormatEtc.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\FileFolderPluginOpen.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\FileFolderPluginOpen.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Panel.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Panel.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelCopy.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelCrc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelDrag.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelFolderChange.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelItemOpen.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelItems.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelKey.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelListNotify.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelMenu.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelOperations.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelSelect.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelSort.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelSplitFile.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\VerCtrl.cpp
+# End Source File
+# End Group
+# Begin Group "Dialog"
+
+# PROP Default_Filter ""
+# Begin Group "Options"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\EditPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\EditPage.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\FoldersPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\FoldersPage.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\LangPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\LangPage.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\MenuPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\MenuPage.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\OptionsDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\SettingsPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\SettingsPage.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\SystemPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\SystemPage.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=.\AboutDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\AboutDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\BrowseDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\BrowseDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ComboDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ComboDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=CopyDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=CopyDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\DialogSize.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\EditDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\EditDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\LinkDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\LinkDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ListViewDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ListViewDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=MessagesDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=MessagesDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=OverwriteDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=OverwriteDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\PasswordDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PasswordDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ProgressDialog2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ProgressDialog2.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\SplitDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\SplitDialog.h
+# End Source File
+# End Group
+# Begin Group "FM Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\ExtractCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\FormatUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\FormatUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\HelpUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\HelpUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\LangUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\LangUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ProgramLocation.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ProgramLocation.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\UpdateCallback100.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\UpdateCallback100.h
+# End Source File
+# End Group
+# Begin Group "7-Zip Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\PropId.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\UniqBlocks.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\UniqBlocks.h
+# End Source File
+# End Group
+# Begin Group "C"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sort.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sort.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.h
+# End Source File
+# End Group
+# Begin Group "Windows"
+
+# PROP Default_Filter ""
+# Begin Group "Control"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ComboBox.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ComboBox.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\CommandBar.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Dialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Dialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Edit.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ImageList.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ListView.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ListView.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ProgressBar.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\PropertyPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\PropertyPage.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ReBar.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Static.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\StatusBar.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ToolBar.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Window2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Window2.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Clipboard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Clipboard.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\COM.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\CommonDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\CommonDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Defs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Device.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileLink.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileMapping.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileSystem.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileSystem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Handle.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryGlobal.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryGlobal.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryLock.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryLock.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Menu.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Menu.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Net.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Net.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\NtCheck.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ProcessUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ProcessUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ResourceString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ResourceString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SecurityUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SecurityUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Shell.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Shell.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Thread.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\TimeUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\TimeUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Window.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Window.h
+# End Source File
+# End Group
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Common\Common.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\ComTry.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Defs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynamicBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynLimBuf.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynLimBuf.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Exception.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Lang.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Lang.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyCom.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Random.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Random.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.h
+# End Source File
+# End Group
+# Begin Group "UI"
+
+# PROP Default_Filter ""
+# Begin Group "UI Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\Common\ArchiveExtractCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveOpenCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveOpenCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\CompressCall.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\CompressCall.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\DefaultName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\DefaultName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\DirItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\EnumDirItems.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\EnumDirItems.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExitCode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExtractingFilePath.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExtractingFilePath.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExtractMode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\HashCalc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\HashCalc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\IFileExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\LoadCodecs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\LoadCodecs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\OpenArchive.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\OpenArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\Property.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\PropIDUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\PropIDUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SetProperties.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SetProperties.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SortUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SortUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\StdAfx.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateAction.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateAction.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdatePair.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdatePair.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateProduce.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateProduce.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\WorkDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\WorkDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ZipRegistry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ZipRegistry.h
+# End Source File
+# End Group
+# Begin Group "Agent"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\Agent\Agent.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\Agent.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\AgentOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\AgentProxy.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\AgentProxy.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\ArchiveFolder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\ArchiveFolderOpen.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\ArchiveFolderOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\IFolderArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\UpdateCallbackAgent.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\UpdateCallbackAgent.h
+# End Source File
+# End Group
+# Begin Group "Explorer"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\Explorer\ContextMenu.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Explorer\ContextMenu.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Explorer\ContextMenuFlags.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Explorer\MyExplorerCommand.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Explorer\RegistryContextMenu.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Explorer\RegistryContextMenu.h
+# End Source File
+# End Group
+# Begin Group "GUI"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\GUI\HashGUI.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\GUI\HashGUI.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\GUI\UpdateCallbackGUI2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\GUI\UpdateCallbackGUI2.h
+# End Source File
+# End Group
+# End Group
+# Begin Group "Compress"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.h
+# End Source File
+# End Group
+# Begin Group "Interface"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\IArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\ICoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IDecl.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IPassword.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IProgress.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\PropID.h
+# End Source File
+# End Group
+# Begin Group "ArchiveCommon"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=.\7zFM.exe.manifest
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zipLogo.ico
+# End Source File
+# Begin Source File
+
+SOURCE=.\Add2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Copy2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Delete2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Extract2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\FilePlugins.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\FilePlugins.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\FM.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Info.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Info2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Move2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\MyCom2.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\MyLoadMenu.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\MyLoadMenu.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\OpenCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\OpenCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\PluginInterface.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\PluginLoader.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\PropertyName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PropertyName.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\SplitUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\SplitUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\StringUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\StringUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\SysIconUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\SysIconUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Test2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\TextPairs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\TextPairs.h
+# End Source File
+# End Target
+# End Project
diff --git a/CPP/7zip/UI/FileManager/FM.dsw b/CPP/7zip/UI/FileManager/FM.dsw
new file mode 100644
index 0000000..1c955d9
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FM.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "FM"=.\FM.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/CPP/7zip/UI/FileManager/FM.ico b/CPP/7zip/UI/FileManager/FM.ico
new file mode 100644
index 0000000..3a0a34d
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FM.ico
diff --git a/CPP/7zip/UI/FileManager/FM.mak b/CPP/7zip/UI/FileManager/FM.mak
new file mode 100644
index 0000000..8b3d97a
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FM.mak
@@ -0,0 +1,100 @@
+CFLAGS = $(CFLAGS) \
+  -DLANG \
+  -DNEW_FOLDER_INTERFACE \
+
+!IFDEF UNDER_CE
+LIBS = $(LIBS) ceshell.lib Commctrl.lib
+!ELSE
+LIBS = $(LIBS) comctl32.lib htmlhelp.lib comdlg32.lib Mpr.lib Gdi32.lib
+CFLAGS = $(CFLAGS) -DWIN_LONG_PATH -DSUPPORT_DEVICE_FILE
+LFLAGS = $(LFLAGS) /DELAYLOAD:mpr.dll
+LIBS = $(LIBS) delayimp.lib
+!ENDIF
+
+FM_OBJS = \
+  $O\App.obj \
+  $O\BrowseDialog.obj \
+  $O\ClassDefs.obj \
+  $O\EnumFormatEtc.obj \
+  $O\ExtractCallback.obj \
+  $O\FileFolderPluginOpen.obj \
+  $O\FilePlugins.obj \
+  $O\FM.obj \
+  $O\FoldersPage.obj \
+  $O\FormatUtils.obj \
+  $O\FSFolder.obj \
+  $O\FSFolderCopy.obj \
+  $O\HelpUtils.obj \
+  $O\LangUtils.obj \
+  $O\MenuPage.obj \
+  $O\MyLoadMenu.obj \
+  $O\OpenCallback.obj \
+  $O\OptionsDialog.obj \
+  $O\Panel.obj \
+  $O\PanelCopy.obj \
+  $O\PanelCrc.obj \
+  $O\PanelDrag.obj \
+  $O\PanelFolderChange.obj \
+  $O\PanelItemOpen.obj \
+  $O\PanelItems.obj \
+  $O\PanelKey.obj \
+  $O\PanelListNotify.obj \
+  $O\PanelMenu.obj \
+  $O\PanelOperations.obj \
+  $O\PanelSelect.obj \
+  $O\PanelSort.obj \
+  $O\PanelSplitFile.obj \
+  $O\ProgramLocation.obj \
+  $O\PropertyName.obj \
+  $O\RegistryAssociations.obj \
+  $O\RegistryPlugins.obj \
+  $O\RegistryUtils.obj \
+  $O\RootFolder.obj \
+  $O\SplitUtils.obj \
+  $O\StringUtils.obj \
+  $O\SysIconUtils.obj \
+  $O\TextPairs.obj \
+  $O\UpdateCallback100.obj \
+  $O\ViewSettings.obj \
+  $O\AboutDialog.obj \
+  $O\ComboDialog.obj \
+  $O\CopyDialog.obj \
+  $O\EditDialog.obj \
+  $O\EditPage.obj \
+  $O\LangPage.obj \
+  $O\ListViewDialog.obj \
+  $O\MessagesDialog.obj \
+  $O\OverwriteDialog.obj \
+  $O\PasswordDialog.obj \
+  $O\ProgressDialog2.obj \
+  $O\SettingsPage.obj \
+  $O\SplitDialog.obj \
+  $O\SystemPage.obj \
+  $O\VerCtrl.obj \
+
+!IFNDEF UNDER_CE
+
+FM_OBJS = $(FM_OBJS) \
+  $O\AltStreamsFolder.obj \
+  $O\FSDrives.obj \
+  $O\LinkDialog.obj \
+  $O\NetFolder.obj \
+
+WIN_OBJS = $(WIN_OBJS) \
+  $O\FileSystem.obj \
+  $O\Net.obj \
+  $O\SecurityUtils.obj \
+
+!ENDIF
+
+C_OBJS = $(C_OBJS) \
+  $O\DllSecur.obj \
+
+AGENT_OBJS = \
+  $O\Agent.obj \
+  $O\AgentOut.obj \
+  $O\AgentProxy.obj \
+  $O\ArchiveFolder.obj \
+  $O\ArchiveFolderOpen.obj \
+  $O\ArchiveFolderOut.obj \
+  $O\UpdateCallbackAgent.obj \
diff --git a/CPP/7zip/UI/FileManager/FSDrives.cpp b/CPP/7zip/UI/FileManager/FSDrives.cpp
new file mode 100644
index 0000000..c563907
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FSDrives.cpp
@@ -0,0 +1,494 @@
+// FSDrives.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/Alloc.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/Defs.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileIO.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/FileSystem.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "../../PropID.h"
+
+#include "FSDrives.h"
+#include "FSFolder.h"
+#include "LangUtils.h"
+#include "SysIconUtils.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NFind;
+
+static const char * const kVolPrefix   = "\\\\.\\";
+static const char * const kSuperPrefix = "\\\\?\\";
+
+FString CDriveInfo::GetDeviceFileIoName() const
+{
+  FString f (kVolPrefix);
+  f += Name;
+  return f;
+}
+
+struct CPhysTempBuffer
+{
+  void *buffer;
+  CPhysTempBuffer(): buffer(0) {}
+  ~CPhysTempBuffer() { MidFree(buffer); }
+};
+
+static HRESULT CopyFileSpec(CFSTR fromPath, CFSTR toPath, bool writeToDisk, UInt64 fileSize,
+    UInt32 bufferSize, UInt64 progressStart, IProgress *progress)
+{
+  NIO::CInFile inFile;
+  if (!inFile.Open(fromPath))
+    return GetLastError();
+  if (fileSize == (UInt64)(Int64)-1)
+  {
+    if (!inFile.GetLength(fileSize))
+      ::GetLastError();
+  }
+  
+  NIO::COutFile outFile;
+  if (writeToDisk)
+  {
+    if (!outFile.Open(toPath, FILE_SHARE_WRITE, OPEN_EXISTING, 0))
+      return GetLastError();
+  }
+  else
+    if (!outFile.Create(toPath, true))
+      return GetLastError();
+  
+  CPhysTempBuffer tempBuffer;
+  tempBuffer.buffer = MidAlloc(bufferSize);
+  if (!tempBuffer.buffer)
+    return E_OUTOFMEMORY;
+ 
+  for (UInt64 pos = 0; pos < fileSize;)
+  {
+    UInt64 progressCur = progressStart + pos;
+    RINOK(progress->SetCompleted(&progressCur));
+    UInt64 rem = fileSize - pos;
+    UInt32 curSize = (UInt32)MyMin(rem, (UInt64)bufferSize);
+    UInt32 processedSize;
+    if (!inFile.Read(tempBuffer.buffer, curSize, processedSize))
+      return GetLastError();
+    if (processedSize == 0)
+      break;
+    curSize = processedSize;
+    if (writeToDisk)
+    {
+      const UInt32 kMask = 0x1FF;
+      curSize = (curSize + kMask) & ~kMask;
+      if (curSize > bufferSize)
+        return E_FAIL;
+    }
+
+    if (!outFile.Write(tempBuffer.buffer, curSize, processedSize))
+      return GetLastError();
+    if (curSize != processedSize)
+      return E_FAIL;
+    pos += curSize;
+  }
+  
+  return S_OK;
+}
+
+static const Byte kProps[] =
+{
+  kpidName,
+  // kpidOutName,
+  kpidTotalSize,
+  kpidFreeSpace,
+  kpidType,
+  kpidVolumeName,
+  kpidFileSystem,
+  kpidClusterSize
+};
+
+static const char * const kDriveTypes[] =
+{
+    "Unknown"
+  , "No Root Dir"
+  , "Removable"
+  , "Fixed"
+  , "Remote"
+  , "CD-ROM"
+  , "RAM disk"
+};
+
+STDMETHODIMP CFSDrives::LoadItems()
+{
+  _drives.Clear();
+
+  FStringVector driveStrings;
+  MyGetLogicalDriveStrings(driveStrings);
+  
+  FOR_VECTOR (i, driveStrings)
+  {
+    CDriveInfo di;
+
+    const FString &driveName = driveStrings[i];
+
+    di.FullSystemName = driveName;
+    if (!driveName.IsEmpty())
+      di.Name.SetFrom(driveName, driveName.Len() - 1);
+    di.ClusterSize = 0;
+    di.DriveSize = 0;
+    di.FreeSpace = 0;
+    di.DriveType = NSystem::MyGetDriveType(driveName);
+    bool needRead = true;
+
+    if (di.DriveType == DRIVE_CDROM || di.DriveType == DRIVE_REMOVABLE)
+    {
+      /*
+      DWORD dwSerialNumber;`
+      if (!::GetVolumeInformation(di.FullSystemName,
+          NULL, 0, &dwSerialNumber, NULL, NULL, NULL, 0))
+      */
+      {
+        needRead = false;
+      }
+    }
+    
+    if (needRead)
+    {
+      DWORD volumeSerialNumber, maximumComponentLength, fileSystemFlags;
+      NSystem::MyGetVolumeInformation(driveName,
+          di.VolumeName,
+          &volumeSerialNumber, &maximumComponentLength, &fileSystemFlags,
+          di.FileSystemName);
+
+      NSystem::MyGetDiskFreeSpace(driveName,
+          di.ClusterSize, di.DriveSize, di.FreeSpace);
+      di.KnownSizes = true;
+      di.KnownSize = true;
+    }
+    
+    _drives.Add(di);
+  }
+
+  if (_volumeMode)
+  {
+    // we must use IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS
+    for (unsigned n = 0; n < 16; n++) // why 16 ?
+    {
+      FString name ("PhysicalDrive");
+      name.Add_UInt32(n);
+      
+      FString fullPath (kVolPrefix);
+      fullPath += name;
+
+      CFileInfo fi;
+      if (!fi.Find(fullPath))
+        continue;
+
+      CDriveInfo di;
+      di.Name = name;
+      di.FullSystemName = fullPath;
+      di.ClusterSize = 0;
+      di.DriveSize = fi.Size;
+      di.FreeSpace = 0;
+      di.DriveType = 0;
+
+      di.IsPhysicalDrive = true;
+      di.KnownSize = true;
+      
+      _drives.Add(di);
+    }
+  }
+
+  return S_OK;
+}
+
+STDMETHODIMP CFSDrives::GetNumberOfItems(UInt32 *numItems)
+{
+  *numItems = _drives.Size();
+  return S_OK;
+}
+
+STDMETHODIMP CFSDrives::GetProperty(UInt32 itemIndex, PROPID propID, PROPVARIANT *value)
+{
+  if (itemIndex >= (UInt32)_drives.Size())
+    return E_INVALIDARG;
+  NCOM::CPropVariant prop;
+  const CDriveInfo &di = _drives[itemIndex];
+  switch (propID)
+  {
+    case kpidIsDir:  prop = !_volumeMode; break;
+    case kpidName:  prop = fs2us(di.Name); break;
+    case kpidOutName:
+      if (!di.Name.IsEmpty() && di.Name.Back() == ':')
+      {
+        FString s = di.Name;
+        s.DeleteBack();
+        AddExt(s, itemIndex);
+        prop = fs2us(s);
+      }
+      break;
+
+    case kpidTotalSize:   if (di.KnownSize) prop = di.DriveSize; break;
+    case kpidFreeSpace:   if (di.KnownSizes) prop = di.FreeSpace; break;
+    case kpidClusterSize: if (di.KnownSizes) prop = di.ClusterSize; break;
+    case kpidType:
+      if (di.DriveType < ARRAY_SIZE(kDriveTypes))
+        prop = kDriveTypes[di.DriveType];
+      break;
+    case kpidVolumeName:  prop = di.VolumeName; break;
+    case kpidFileSystem:  prop = di.FileSystemName; break;
+  }
+  prop.Detach(value);
+  return S_OK;
+}
+
+HRESULT CFSDrives::BindToFolderSpec(CFSTR name, IFolderFolder **resultFolder)
+{
+  *resultFolder = 0;
+  if (_volumeMode)
+    return S_OK;
+  NFsFolder::CFSFolder *fsFolderSpec = new NFsFolder::CFSFolder;
+  CMyComPtr<IFolderFolder> subFolder = fsFolderSpec;
+  FString path;
+  if (_superMode)
+    path = kSuperPrefix;
+  path += name;
+  RINOK(fsFolderSpec->Init(path));
+  *resultFolder = subFolder.Detach();
+  return S_OK;
+}
+
+STDMETHODIMP CFSDrives::BindToFolder(UInt32 index, IFolderFolder **resultFolder)
+{
+  *resultFolder = 0;
+  if (index >= (UInt32)_drives.Size())
+    return E_INVALIDARG;
+  const CDriveInfo &di = _drives[index];
+  /*
+  if (_volumeMode)
+  {
+    *resultFolder = 0;
+    CPhysDriveFolder *folderSpec = new CPhysDriveFolder;
+    CMyComPtr<IFolderFolder> subFolder = folderSpec;
+    RINOK(folderSpec->Init(di.Name));
+    *resultFolder = subFolder.Detach();
+    return S_OK;
+  }
+  */
+  return BindToFolderSpec(di.FullSystemName, resultFolder);
+}
+
+STDMETHODIMP CFSDrives::BindToFolder(const wchar_t *name, IFolderFolder **resultFolder)
+{
+  return BindToFolderSpec(us2fs(name), resultFolder);
+}
+
+STDMETHODIMP CFSDrives::BindToParentFolder(IFolderFolder **resultFolder)
+{
+  *resultFolder = 0;
+  return S_OK;
+}
+
+IMP_IFolderFolder_Props(CFSDrives)
+
+STDMETHODIMP CFSDrives::GetFolderProperty(PROPID propID, PROPVARIANT *value)
+{
+  COM_TRY_BEGIN
+  NCOM::CPropVariant prop;
+  switch (propID)
+  {
+    case kpidType: prop = "FSDrives"; break;
+    case kpidPath:
+      if (_volumeMode)
+        prop = kVolPrefix;
+      else if (_superMode)
+        prop = kSuperPrefix;
+      else
+        prop = (UString)LangString(IDS_COMPUTER) + WCHAR_PATH_SEPARATOR;
+      break;
+  }
+  prop.Detach(value);
+  return S_OK;
+  COM_TRY_END
+}
+
+
+STDMETHODIMP CFSDrives::GetSystemIconIndex(UInt32 index, Int32 *iconIndex)
+{
+  *iconIndex = 0;
+  const CDriveInfo &di = _drives[index];
+  if (di.IsPhysicalDrive)
+    return S_OK;
+  int iconIndexTemp;
+  if (GetRealIconIndex(di.FullSystemName, 0, iconIndexTemp) != 0)
+  {
+    *iconIndex = iconIndexTemp;
+    return S_OK;
+  }
+  return GetLastError();
+}
+
+void CFSDrives::AddExt(FString &s, unsigned index) const
+{
+  s += '.';
+  const CDriveInfo &di = _drives[index];
+  const char *ext;
+  if (di.DriveType == DRIVE_CDROM)
+    ext = "iso";
+  else if (di.FileSystemName.IsPrefixedBy_Ascii_NoCase("NTFS"))
+    ext = "ntfs";
+  else if (di.FileSystemName.IsPrefixedBy_Ascii_NoCase("FAT"))
+    ext = "fat";
+  else
+    ext = "img";
+  s += ext;
+}
+
+HRESULT CFSDrives::GetFileSize(unsigned index, UInt64 &fileSize) const
+{
+  NIO::CInFile inFile;
+  if (!inFile.Open(_drives[index].GetDeviceFileIoName()))
+    return GetLastError();
+  if (!inFile.SizeDefined)
+    return E_FAIL;
+  fileSize = inFile.Size;
+  return S_OK;
+}
+
+STDMETHODIMP CFSDrives::CopyTo(Int32 moveMode, const UInt32 *indices, UInt32 numItems,
+    Int32 /* includeAltStreams */, Int32 /* replaceAltStreamColon */,
+    const wchar_t *path, IFolderOperationsExtractCallback *callback)
+{
+  if (numItems == 0)
+    return S_OK;
+  
+  if (moveMode)
+    return E_NOTIMPL;
+
+  if (!_volumeMode)
+    return E_NOTIMPL;
+
+  UInt64 totalSize = 0;
+  UInt32 i;
+  for (i = 0; i < numItems; i++)
+  {
+    const CDriveInfo &di = _drives[indices[i]];
+    if (di.KnownSize)
+      totalSize += di.DriveSize;
+  }
+  RINOK(callback->SetTotal(totalSize));
+  RINOK(callback->SetNumFiles(numItems));
+  
+  FString destPath = us2fs(path);
+  if (destPath.IsEmpty())
+    return E_INVALIDARG;
+
+  bool isAltDest = NName::IsAltPathPrefix(destPath);
+  bool isDirectPath = (!isAltDest && !IsPathSepar(destPath.Back()));
+  
+  if (isDirectPath)
+  {
+    if (numItems > 1)
+      return E_INVALIDARG;
+  }
+
+  UInt64 completedSize = 0;
+  RINOK(callback->SetCompleted(&completedSize));
+  
+  for (i = 0; i < numItems; i++)
+  {
+    unsigned index = indices[i];
+    const CDriveInfo &di = _drives[index];
+    FString destPath2 = destPath;
+
+    if (!isDirectPath)
+    {
+      FString destName = di.Name;
+      if (!destName.IsEmpty() && destName.Back() == ':')
+      {
+        destName.DeleteBack();
+        AddExt(destName, index);
+      }
+      destPath2 += destName;
+    }
+    
+    FString srcPath = di.GetDeviceFileIoName();
+
+    UInt64 fileSize = 0;
+    if (GetFileSize(index, fileSize) != S_OK)
+    {
+      return E_FAIL;
+    }
+    if (!di.KnownSize)
+    {
+      totalSize += fileSize;
+      RINOK(callback->SetTotal(totalSize));
+    }
+    
+    Int32 writeAskResult;
+    CMyComBSTR destPathResult;
+    RINOK(callback->AskWrite(fs2us(srcPath), BoolToInt(false), NULL, &fileSize,
+        fs2us(destPath2), &destPathResult, &writeAskResult));
+
+    if (!IntToBool(writeAskResult))
+    {
+      if (totalSize >= fileSize)
+        totalSize -= fileSize;
+      RINOK(callback->SetTotal(totalSize));
+      continue;
+    }
+    
+    RINOK(callback->SetCurrentFilePath(fs2us(srcPath)));
+    
+    static const UInt32 kBufferSize = (4 << 20);
+    UInt32 bufferSize = (di.DriveType == DRIVE_REMOVABLE) ? (18 << 10) * 4 : kBufferSize;
+    RINOK(CopyFileSpec(srcPath, us2fs(destPathResult), false, fileSize, bufferSize, completedSize, callback));
+    completedSize += fileSize;
+  }
+
+  return S_OK;
+}
+
+STDMETHODIMP CFSDrives::CopyFrom(Int32 /* moveMode */, const wchar_t * /* fromFolderPath */,
+    const wchar_t * const * /* itemsPaths */, UInt32 /* numItems */, IProgress * /* progress */)
+{
+  return E_NOTIMPL;
+}
+
+STDMETHODIMP CFSDrives::CopyFromFile(UInt32 /* index */, const wchar_t * /* fullFilePath */, IProgress * /* progress */)
+{
+  return E_NOTIMPL;
+}
+
+STDMETHODIMP CFSDrives::CreateFolder(const wchar_t * /* name */, IProgress * /* progress */)
+{
+  return E_NOTIMPL;
+}
+
+STDMETHODIMP CFSDrives::CreateFile(const wchar_t * /* name */, IProgress * /* progress */)
+{
+  return E_NOTIMPL;
+}
+
+STDMETHODIMP CFSDrives::Rename(UInt32 /* index */, const wchar_t * /* newName */, IProgress * /* progress */)
+{
+  return E_NOTIMPL;
+}
+
+STDMETHODIMP CFSDrives::Delete(const UInt32 * /* indices */, UInt32 /* numItems */, IProgress * /* progress */)
+{
+  return E_NOTIMPL;
+}
+
+STDMETHODIMP CFSDrives::SetProperty(UInt32 /* index */, PROPID /* propID */,
+    const PROPVARIANT * /* value */, IProgress * /* progress */)
+{
+  return E_NOTIMPL;
+}
diff --git a/CPP/7zip/UI/FileManager/FSDrives.h b/CPP/7zip/UI/FileManager/FSDrives.h
new file mode 100644
index 0000000..f12e4da
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FSDrives.h
@@ -0,0 +1,59 @@
+// FSDrives.h
+
+#ifndef __FS_DRIVES_H
+#define __FS_DRIVES_H
+
+#include "../../../Common/MyCom.h"
+#include "../../../Common/MyString.h"
+
+#include "IFolder.h"
+
+struct CDriveInfo
+{
+  FString Name;
+  FString FullSystemName;
+  UInt64 DriveSize;
+  UInt64 FreeSpace;
+  UInt64 ClusterSize;
+  // UString Type;
+  UString VolumeName;
+  UString FileSystemName;
+  UINT DriveType;
+
+  bool KnownSize;
+  bool KnownSizes;
+  bool IsPhysicalDrive;
+
+  FString GetDeviceFileIoName() const;
+  CDriveInfo(): KnownSize(false), KnownSizes(false), IsPhysicalDrive(false) {}
+};
+
+class CFSDrives:
+  public IFolderFolder,
+  public IFolderOperations,
+  public IFolderGetSystemIconIndex,
+  public CMyUnknownImp
+{
+  CObjectVector<CDriveInfo> _drives;
+  bool _volumeMode;
+  bool _superMode;
+
+  HRESULT BindToFolderSpec(CFSTR name, IFolderFolder **resultFolder);
+  void AddExt(FString &s, unsigned index) const;
+  HRESULT GetFileSize(unsigned index, UInt64 &fileSize) const;
+public:
+  MY_UNKNOWN_IMP2(IFolderGetSystemIconIndex, IFolderOperations)
+
+  INTERFACE_FolderFolder(;)
+  INTERFACE_FolderOperations(;)
+
+  STDMETHOD(GetSystemIconIndex)(UInt32 index, Int32 *iconIndex);
+
+  void Init(bool volMode = false, bool superMode = false)
+  {
+    _volumeMode = volMode;
+    _superMode = superMode;
+  }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/FSFolder.cpp b/CPP/7zip/UI/FileManager/FSFolder.cpp
new file mode 100644
index 0000000..f3e04b3
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FSFolder.cpp
@@ -0,0 +1,1107 @@
+// FSFolder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/Defs.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/UTFConvert.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileIO.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "../../PropID.h"
+
+#include "FSDrives.h"
+#include "FSFolder.h"
+
+#ifndef UNDER_CE
+#include "NetFolder.h"
+#endif
+
+#include "SysIconUtils.h"
+
+#if _WIN32_WINNT < 0x0501
+#ifdef _APISETFILE_
+// Windows SDK 8.1 defines in fileapi.h the function GetCompressedFileSizeW only if _WIN32_WINNT >= 0x0501
+// But real support version for that function is NT 3.1 (probably)
+// So we must define GetCompressedFileSizeW
+EXTERN_C_BEGIN
+WINBASEAPI DWORD WINAPI GetCompressedFileSizeW(LPCWSTR lpFileName, LPDWORD lpFileSizeHigh);
+EXTERN_C_END
+#endif
+#endif
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NFind;
+using namespace NDir;
+using namespace NName;
+
+#ifndef USE_UNICODE_FSTRING
+int CompareFileNames_ForFolderList(const FChar *s1, const FChar *s2)
+{
+  return CompareFileNames_ForFolderList(fs2us(s1), fs2us(s2));
+}
+#endif
+
+namespace NFsFolder {
+
+static const Byte kProps[] =
+{
+  kpidName,
+  kpidSize,
+  kpidMTime,
+  kpidCTime,
+  kpidATime,
+  kpidAttrib,
+  kpidPackSize,
+  #ifdef FS_SHOW_LINKS_INFO
+  kpidINode,
+  kpidLinks,
+  #endif
+  kpidComment,
+  kpidNumSubDirs,
+  kpidNumSubFiles,
+  kpidPrefix
+};
+
+HRESULT CFSFolder::Init(const FString &path /* , IFolderFolder *parentFolder */)
+{
+  // _parentFolder = parentFolder;
+  _path = path;
+
+  #ifdef _WIN32
+
+  _findChangeNotification.FindFirst(_path, false,
+        FILE_NOTIFY_CHANGE_FILE_NAME
+      | FILE_NOTIFY_CHANGE_DIR_NAME
+      | FILE_NOTIFY_CHANGE_ATTRIBUTES
+      | FILE_NOTIFY_CHANGE_SIZE
+      | FILE_NOTIFY_CHANGE_LAST_WRITE
+      /*
+      | FILE_NOTIFY_CHANGE_LAST_ACCESS
+      | FILE_NOTIFY_CHANGE_CREATION
+      | FILE_NOTIFY_CHANGE_SECURITY
+      */
+      );
+
+  if (!_findChangeNotification.IsHandleAllocated())
+  {
+    DWORD lastError = GetLastError();
+    CFindFile findFile;
+    CFileInfo fi;
+    FString path2 = _path;
+    path2 += '*'; // CHAR_ANY_MASK;
+    if (!findFile.FindFirst(path2, fi))
+      return lastError;
+  }
+
+  #endif
+  
+  return S_OK;
+}
+
+
+HRESULT CFsFolderStat::Enumerate()
+{
+  if (Progress)
+  {
+    RINOK(Progress->SetCompleted(NULL));
+  }
+  Path.Add_PathSepar();
+  const unsigned len = Path.Len();
+  CEnumerator enumerator;
+  enumerator.SetDirPrefix(Path);
+  CDirEntry fi;
+  while (enumerator.Next(fi))
+  {
+    if (fi.IsDir())
+    {
+      NumFolders++;
+      Path.DeleteFrom(len);
+      Path += fi.Name;
+      RINOK(Enumerate());
+    }
+    else
+    {
+      NumFiles++;
+      Size += fi.Size;
+    }
+  }
+  return S_OK;
+}
+
+#ifndef UNDER_CE
+
+bool MyGetCompressedFileSizeW(CFSTR path, UInt64 &size);
+bool MyGetCompressedFileSizeW(CFSTR path, UInt64 &size)
+{
+  DWORD highPart;
+  DWORD lowPart = INVALID_FILE_SIZE;
+  IF_USE_MAIN_PATH
+  {
+    lowPart = ::GetCompressedFileSizeW(fs2us(path), &highPart);
+    if (lowPart != INVALID_FILE_SIZE || ::GetLastError() == NO_ERROR)
+    {
+      size = ((UInt64)highPart << 32) | lowPart;
+      return true;
+    }
+  }
+  #ifdef WIN_LONG_PATH
+  if (USE_SUPER_PATH)
+  {
+    UString superPath;
+    if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+    {
+      lowPart = ::GetCompressedFileSizeW(superPath, &highPart);
+      if (lowPart != INVALID_FILE_SIZE || ::GetLastError() == NO_ERROR)
+      {
+        size = ((UInt64)highPart << 32) | lowPart;
+        return true;
+      }
+    }
+  }
+  #endif
+  return false;
+}
+
+#endif
+
+HRESULT CFSFolder::LoadSubItems(int dirItem, const FString &relPrefix)
+{
+  const unsigned startIndex = Folders.Size();
+  {
+    CEnumerator enumerator;
+    enumerator.SetDirPrefix(_path + relPrefix);
+    CDirItem fi;
+    fi.FolderStat_Defined = false;
+    fi.NumFolders = 0;
+    fi.NumFiles = 0;
+    fi.Parent = dirItem;
+    
+    while (enumerator.Next(fi))
+    {
+      if (fi.IsDir())
+      {
+        fi.Size = 0;
+        if (_flatMode)
+          Folders.Add(relPrefix + fi.Name + FCHAR_PATH_SEPARATOR);
+      }
+      else
+      {
+        /*
+        fi.PackSize_Defined = true;
+        if (!MyGetCompressedFileSizeW(_path + relPrefix + fi.Name, fi.PackSize))
+          fi.PackSize = fi.Size;
+        */
+      }
+      
+      #ifndef UNDER_CE
+
+      fi.Reparse.Free();
+      fi.PackSize_Defined = false;
+    
+      #ifdef FS_SHOW_LINKS_INFO
+      fi.FileInfo_Defined = false;
+      fi.FileInfo_WasRequested = false;
+      fi.FileIndex = 0;
+      fi.NumLinks = 0;
+      #endif
+      
+      fi.PackSize = fi.Size;
+      if (fi.HasReparsePoint())
+      {
+        fi.FileInfo_WasRequested = true;
+        BY_HANDLE_FILE_INFORMATION info;
+        NIO::GetReparseData(_path + relPrefix + fi.Name, fi.Reparse, &info);
+        fi.NumLinks = info.nNumberOfLinks;
+        fi.FileIndex = (((UInt64)info.nFileIndexHigh) << 32) + info.nFileIndexLow;
+        fi.FileInfo_Defined = true;
+      }
+
+      #endif
+
+      /* unsigned fileIndex = */ Files.Add(fi);
+
+      #if defined(_WIN32) && !defined(UNDER_CE)
+      /*
+      if (_scanAltStreams)
+      {
+        CStreamEnumerator enumerator(_path + relPrefix + fi.Name);
+        CStreamInfo si;
+        for (;;)
+        {
+          bool found;
+          if (!enumerator.Next(si, found))
+          {
+            // if (GetLastError() == ERROR_ACCESS_DENIED)
+            //   break;
+            // return E_FAIL;
+            break;
+          }
+          if (!found)
+            break;
+          if (si.IsMainStream())
+            continue;
+          CAltStream ss;
+          ss.Parent = fileIndex;
+          ss.Name = si.GetReducedName();
+          ss.Size = si.Size;
+          ss.PackSize_Defined = false;
+          ss.PackSize = si.Size;
+          Streams.Add(ss);
+        }
+      }
+      */
+      #endif
+    }
+  }
+  if (!_flatMode)
+    return S_OK;
+
+  const unsigned endIndex = Folders.Size();
+  for (unsigned i = startIndex; i < endIndex; i++)
+    LoadSubItems(i, Folders[i]);
+  return S_OK;
+}
+
+STDMETHODIMP CFSFolder::LoadItems()
+{
+  Int32 dummy;
+  WasChanged(&dummy);
+  Clear();
+  RINOK(LoadSubItems(-1, FString()));
+  _commentsAreLoaded = false;
+  return S_OK;
+}
+
+static CFSTR const kDescriptionFileName = FTEXT("descript.ion");
+
+bool CFSFolder::LoadComments()
+{
+  _comments.Clear();
+  _commentsAreLoaded = true;
+  NIO::CInFile file;
+  if (!file.Open(_path + kDescriptionFileName))
+    return false;
+  UInt64 len;
+  if (!file.GetLength(len))
+    return false;
+  if (len >= (1 << 28))
+    return false;
+  AString s;
+  char *p = s.GetBuf((unsigned)(size_t)len);
+  size_t processedSize;
+  if (!file.ReadFull(p, (unsigned)(size_t)len, processedSize))
+    return false;
+  s.ReleaseBuf_CalcLen((unsigned)(size_t)len);
+  if (processedSize != len)
+    return false;
+  file.Close();
+  UString unicodeString;
+  if (!ConvertUTF8ToUnicode(s, unicodeString))
+    return false;
+  return _comments.ReadFromString(unicodeString);
+}
+
+bool CFSFolder::SaveComments()
+{
+  AString utf;
+  {
+    UString unicode;
+    _comments.SaveToString(unicode);
+    ConvertUnicodeToUTF8(unicode, utf);
+  }
+  if (!utf.IsAscii())
+    utf.Insert(0, "\xEF\xBB\xBF" "\r\n");
+
+  FString path = _path + kDescriptionFileName;
+  // We must set same attrib. COutFile::CreateAlways can fail, if file has another attrib.
+  DWORD attrib = FILE_ATTRIBUTE_NORMAL;
+  {
+    CFileInfo fi;
+    if (fi.Find(path))
+      attrib = fi.Attrib;
+  }
+  NIO::COutFile file;
+  if (!file.CreateAlways(path, attrib))
+    return false;
+  UInt32 processed;
+  file.Write(utf, utf.Len(), processed);
+  _commentsAreLoaded = false;
+  return true;
+}
+
+STDMETHODIMP CFSFolder::GetNumberOfItems(UInt32 *numItems)
+{
+  *numItems = Files.Size() /* + Streams.Size() */;
+  return S_OK;
+}
+
+#ifdef USE_UNICODE_FSTRING
+
+STDMETHODIMP CFSFolder::GetItemPrefix(UInt32 index, const wchar_t **name, unsigned *len)
+{
+  *name = 0;
+  *len = 0;
+  /*
+  if (index >= Files.Size())
+    index = Streams[index - Files.Size()].Parent;
+  */
+  CDirItem &fi = Files[index];
+  if (fi.Parent >= 0)
+  {
+    const FString &fo = Folders[fi.Parent];
+    USE_UNICODE_FSTRING
+    *name = fo;
+    *len = fo.Len();
+  }
+  return S_OK;
+}
+
+STDMETHODIMP CFSFolder::GetItemName(UInt32 index, const wchar_t **name, unsigned *len)
+{
+  *name = 0;
+  *len = 0;
+  if (index < Files.Size())
+  {
+    CDirItem &fi = Files[index];
+    *name = fi.Name;
+    *len = fi.Name.Len();
+    return S_OK;
+  }
+  else
+  {
+    // const CAltStream &ss = Streams[index - Files.Size()];
+    // *name = ss.Name;
+    // *len = ss.Name.Len();
+    //
+    // change it;
+  }
+  return S_OK;
+}
+
+STDMETHODIMP_(UInt64) CFSFolder::GetItemSize(UInt32 index)
+{
+  /*
+  if (index >= Files.Size())
+    return Streams[index - Files.Size()].Size;
+  */
+  CDirItem &fi = Files[index];
+  return fi.IsDir() ? 0 : fi.Size;
+}
+
+#endif
+
+#ifdef FS_SHOW_LINKS_INFO
+bool CFSFolder::ReadFileInfo(CDirItem &di)
+{
+  di.FileInfo_WasRequested = true;
+  BY_HANDLE_FILE_INFORMATION info;
+  memset(&info, 0, sizeof(info)); // for vc6-O2
+  if (!NIO::CFileBase::GetFileInformation(_path + GetRelPath(di), &info))
+    return false;
+  di.NumLinks = info.nNumberOfLinks;
+  di.FileIndex = (((UInt64)info.nFileIndexHigh) << 32) + info.nFileIndexLow;
+  di.FileInfo_Defined = true;
+  return true;
+}
+#endif
+
+STDMETHODIMP CFSFolder::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
+{
+  NCOM::CPropVariant prop;
+  /*
+  if (index >= (UInt32)Files.Size())
+  {
+    CAltStream &ss = Streams[index - Files.Size()];
+    CDirItem &fi = Files[ss.Parent];
+    switch (propID)
+    {
+      case kpidIsDir: prop = false; break;
+      case kpidIsAltStream: prop = true; break;
+      case kpidName: prop = fs2us(fi.Name) + ss.Name; break;
+      case kpidSize: prop = ss.Size; break;
+      case kpidPackSize:
+        #ifdef UNDER_CE
+        prop = ss.Size;
+        #else
+        if (!ss.PackSize_Defined)
+        {
+          ss.PackSize_Defined = true;
+          if (!MyGetCompressedFileSizeW(_path + GetRelPath(fi) + us2fs(ss.Name), ss.PackSize))
+            ss.PackSize = ss.Size;
+        }
+        prop = ss.PackSize;
+        #endif
+        break;
+      case kpidComment: break;
+      default: index = ss.Parent;
+    }
+    if (index >= (UInt32)Files.Size())
+    {
+      prop.Detach(value);
+      return S_OK;
+    }
+  }
+  */
+  CDirItem &fi = Files[index];
+  switch (propID)
+  {
+    case kpidIsDir: prop = fi.IsDir(); break;
+    case kpidIsAltStream: prop = false; break;
+    case kpidName: prop = fs2us(fi.Name); break;
+    case kpidSize: if (!fi.IsDir() || fi.FolderStat_Defined) prop = fi.Size; break;
+    case kpidPackSize:
+      #ifdef UNDER_CE
+      prop = fi.Size;
+      #else
+      if (!fi.PackSize_Defined)
+      {
+        fi.PackSize_Defined = true;
+        if (fi.IsDir () || !MyGetCompressedFileSizeW(_path + GetRelPath(fi), fi.PackSize))
+          fi.PackSize = fi.Size;
+      }
+      prop = fi.PackSize;
+      #endif
+      break;
+
+    #ifdef FS_SHOW_LINKS_INFO
+
+    case kpidLinks:
+      #ifdef UNDER_CE
+      // prop = fi.NumLinks;
+      #else
+      if (!fi.FileInfo_WasRequested)
+        ReadFileInfo(fi);
+      if (fi.FileInfo_Defined)
+        prop = fi.NumLinks;
+      #endif
+      break;
+    
+    case kpidINode:
+      #ifdef UNDER_CE
+      // prop = fi.FileIndex;
+      #else
+      if (!fi.FileInfo_WasRequested)
+        ReadFileInfo(fi);
+      if (fi.FileInfo_Defined)
+        prop = fi.FileIndex;
+      #endif
+      break;
+    
+    #endif
+
+    case kpidAttrib: prop = (UInt32)fi.Attrib; break;
+    case kpidCTime: prop = fi.CTime; break;
+    case kpidATime: prop = fi.ATime; break;
+    case kpidMTime: prop = fi.MTime; break;
+    case kpidComment:
+    {
+      if (!_commentsAreLoaded)
+        LoadComments();
+      UString comment;
+      if (_comments.GetValue(fs2us(GetRelPath(fi)), comment))
+      {
+        int pos = comment.Find((wchar_t)4);
+        if (pos >= 0)
+          comment.DeleteFrom((unsigned)pos);
+        prop = comment;
+      }
+      break;
+    }
+    case kpidPrefix:
+      if (fi.Parent >= 0)
+        prop = fs2us(Folders[fi.Parent]);
+      break;
+    case kpidNumSubDirs: if (fi.IsDir() && fi.FolderStat_Defined) prop = fi.NumFolders; break;
+    case kpidNumSubFiles: if (fi.IsDir() && fi.FolderStat_Defined) prop = fi.NumFiles; break;
+  }
+  prop.Detach(value);
+  return S_OK;
+}
+
+
+// ---------- IArchiveGetRawProps ----------
+
+
+STDMETHODIMP CFSFolder::GetNumRawProps(UInt32 *numProps)
+{
+  *numProps = 1;
+  return S_OK;
+}
+
+STDMETHODIMP CFSFolder::GetRawPropInfo(UInt32 /* index */, BSTR *name, PROPID *propID)
+{
+  *name = NULL;
+  *propID = kpidNtReparse;
+  return S_OK;
+}
+
+STDMETHODIMP CFSFolder::GetParent(UInt32 /* index */, UInt32 * /* parent */, UInt32 * /* parentType */)
+{
+  return E_FAIL;
+}
+
+STDMETHODIMP CFSFolder::GetRawProp(UInt32
+  #ifndef UNDER_CE
+  index
+  #endif
+  , PROPID
+  #ifndef UNDER_CE
+  propID
+  #endif
+  , const void **data, UInt32 *dataSize, UInt32 *propType)
+{
+  *data = NULL;
+  *dataSize = 0;
+  *propType = 0;
+  
+  #ifndef UNDER_CE
+  if (propID == kpidNtReparse)
+  {
+    const CDirItem &fi = Files[index];
+    const CByteBuffer &buf = fi.Reparse;
+    if (buf.Size() == 0)
+      return S_OK;
+    *data = buf;
+    *dataSize = (UInt32)buf.Size();
+    *propType = NPropDataType::kRaw;
+    return S_OK;
+  }
+  #endif
+  
+  return S_OK;
+}
+
+
+// returns Position of extension including '.'
+
+static inline CFSTR GetExtensionPtr(const FString &name)
+{
+  int dotPos = name.ReverseFind_Dot();
+  return name.Ptr((dotPos < 0) ? name.Len() : dotPos);
+}
+
+STDMETHODIMP_(Int32) CFSFolder::CompareItems(UInt32 index1, UInt32 index2, PROPID propID, Int32 /* propIsRaw */)
+{
+  /*
+  const CAltStream *ss1 = NULL;
+  const CAltStream *ss2 = NULL;
+  if (index1 >= (UInt32)Files.Size()) { ss1 = &Streams[index1 - Files.Size()]; index1 = ss1->Parent; }
+  if (index2 >= (UInt32)Files.Size()) { ss2 = &Streams[index2 - Files.Size()]; index2 = ss2->Parent; }
+  */
+  CDirItem &fi1 = Files[index1];
+  CDirItem &fi2 = Files[index2];
+
+  switch (propID)
+  {
+    case kpidName:
+    {
+      int comp = CompareFileNames_ForFolderList(fi1.Name, fi2.Name);
+      /*
+      if (comp != 0)
+        return comp;
+      if (!ss1)
+        return ss2 ? -1 : 0;
+      if (!ss2)
+        return 1;
+      return MyStringCompareNoCase(ss1->Name, ss2->Name);
+      */
+      return comp;
+    }
+    case kpidSize:
+      return MyCompare(
+          /* ss1 ? ss1->Size : */ fi1.Size,
+          /* ss2 ? ss2->Size : */ fi2.Size);
+    case kpidAttrib: return MyCompare(fi1.Attrib, fi2.Attrib);
+    case kpidCTime: return CompareFileTime(&fi1.CTime, &fi2.CTime);
+    case kpidATime: return CompareFileTime(&fi1.ATime, &fi2.ATime);
+    case kpidMTime: return CompareFileTime(&fi1.MTime, &fi2.MTime);
+    case kpidIsDir:
+    {
+      bool isDir1 = /* ss1 ? false : */ fi1.IsDir();
+      bool isDir2 = /* ss2 ? false : */ fi2.IsDir();
+      if (isDir1 == isDir2)
+        return 0;
+      return isDir1 ? -1 : 1;
+    }
+    case kpidPackSize:
+    {
+      #ifdef UNDER_CE
+      return MyCompare(fi1.Size, fi2.Size);
+      #else
+      // PackSize can be undefined here
+      return MyCompare(
+          /* ss1 ? ss1->PackSize : */ fi1.PackSize,
+          /* ss2 ? ss2->PackSize : */ fi2.PackSize);
+      #endif
+    }
+    
+    #ifdef FS_SHOW_LINKS_INFO
+    case kpidINode:
+    {
+      #ifndef UNDER_CE
+      if (!fi1.FileInfo_WasRequested) ReadFileInfo(fi1);
+      if (!fi2.FileInfo_WasRequested) ReadFileInfo(fi2);
+      return MyCompare(
+          fi1.FileIndex,
+          fi2.FileIndex);
+      #endif
+    }
+    case kpidLinks:
+    {
+      #ifndef UNDER_CE
+      if (!fi1.FileInfo_WasRequested) ReadFileInfo(fi1);
+      if (!fi2.FileInfo_WasRequested) ReadFileInfo(fi2);
+      return MyCompare(
+          fi1.NumLinks,
+          fi2.NumLinks);
+      #endif
+    }
+    #endif
+
+    case kpidComment:
+    {
+      // change it !
+      UString comment1, comment2;
+      _comments.GetValue(fs2us(GetRelPath(fi1)), comment1);
+      _comments.GetValue(fs2us(GetRelPath(fi2)), comment2);
+      return MyStringCompareNoCase(comment1, comment2);
+    }
+    case kpidPrefix:
+      if (fi1.Parent < 0) return (fi2.Parent < 0) ? 0 : -1;
+      if (fi2.Parent < 0) return 1;
+      return CompareFileNames_ForFolderList(
+          Folders[fi1.Parent],
+          Folders[fi2.Parent]);
+    case kpidExtension:
+      return CompareFileNames_ForFolderList(
+          GetExtensionPtr(fi1.Name),
+          GetExtensionPtr(fi2.Name));
+  }
+  
+  return 0;
+}
+
+HRESULT CFSFolder::BindToFolderSpec(CFSTR name, IFolderFolder **resultFolder)
+{
+  *resultFolder = 0;
+  CFSFolder *folderSpec = new CFSFolder;
+  CMyComPtr<IFolderFolder> subFolder = folderSpec;
+  RINOK(folderSpec->Init(_path + name + FCHAR_PATH_SEPARATOR));
+  *resultFolder = subFolder.Detach();
+  return S_OK;
+}
+
+/*
+void CFSFolder::GetPrefix(const CDirItem &item, FString &prefix) const
+{
+  if (item.Parent >= 0)
+    prefix = Folders[item.Parent];
+  else
+    prefix.Empty();
+}
+*/
+
+/*
+void CFSFolder::GetPrefix(const CDirItem &item, FString &prefix) const
+{
+  int parent = item.Parent;
+
+  unsigned len = 0;
+
+  while (parent >= 0)
+  {
+    const CDirItem &cur = Files[parent];
+    len += cur.Name.Len() + 1;
+    parent = cur.Parent;
+  }
+
+  wchar_t *p = prefix.GetBuf_SetEnd(len) + len;
+  parent = item.Parent;
+
+  while (parent >= 0)
+  {
+    const CDirItem &cur = Files[parent];
+    *(--p) = FCHAR_PATH_SEPARATOR;
+    p -= cur.Name.Len();
+    wmemcpy(p, cur.Name, cur.Name.Len());
+    parent = cur.Parent;
+  }
+}
+*/
+
+FString CFSFolder::GetRelPath(const CDirItem &item) const
+{
+  if (item.Parent < 0)
+    return item.Name;
+  return Folders[item.Parent] + item.Name;
+}
+
+STDMETHODIMP CFSFolder::BindToFolder(UInt32 index, IFolderFolder **resultFolder)
+{
+  *resultFolder = 0;
+  const CDirItem &fi = Files[index];
+  if (!fi.IsDir())
+    return E_INVALIDARG;
+  return BindToFolderSpec(GetRelPath(fi), resultFolder);
+}
+
+STDMETHODIMP CFSFolder::BindToFolder(const wchar_t *name, IFolderFolder **resultFolder)
+{
+  return BindToFolderSpec(us2fs(name), resultFolder);
+}
+
+STDMETHODIMP CFSFolder::BindToParentFolder(IFolderFolder **resultFolder)
+{
+  *resultFolder = 0;
+  /*
+  if (_parentFolder)
+  {
+    CMyComPtr<IFolderFolder> parentFolder = _parentFolder;
+    *resultFolder = parentFolder.Detach();
+    return S_OK;
+  }
+  */
+  if (_path.IsEmpty())
+    return E_INVALIDARG;
+  
+  #ifndef UNDER_CE
+
+  if (IsDriveRootPath_SuperAllowed(_path))
+  {
+    CFSDrives *drivesFolderSpec = new CFSDrives;
+    CMyComPtr<IFolderFolder> drivesFolder = drivesFolderSpec;
+    drivesFolderSpec->Init(false, IsSuperPath(_path));
+    *resultFolder = drivesFolder.Detach();
+    return S_OK;
+  }
+  
+  int pos = _path.ReverseFind_PathSepar();
+  if (pos < 0 || pos != (int)_path.Len() - 1)
+    return E_FAIL;
+  FString parentPath = _path.Left(pos);
+  pos = parentPath.ReverseFind_PathSepar();
+  parentPath.DeleteFrom((unsigned)(pos + 1));
+
+  if (NName::IsDrivePath_SuperAllowed(parentPath))
+  {
+    CFSFolder *parentFolderSpec = new CFSFolder;
+    CMyComPtr<IFolderFolder> parentFolder = parentFolderSpec;
+    if (parentFolderSpec->Init(parentPath) == S_OK)
+    {
+      *resultFolder = parentFolder.Detach();
+      return S_OK;
+    }
+  }
+  
+  /*
+  FString parentPathReduced = parentPath.Left(pos);
+  
+  pos = parentPathReduced.ReverseFind_PathSepar();
+  if (pos == 1)
+  {
+    if (!IS_PATH_SEPAR_CHAR(parentPath[0]))
+      return E_FAIL;
+    CNetFolder *netFolderSpec = new CNetFolder;
+    CMyComPtr<IFolderFolder> netFolder = netFolderSpec;
+    netFolderSpec->Init(fs2us(parentPath));
+    *resultFolder = netFolder.Detach();
+    return S_OK;
+  }
+  */
+  
+  #endif
+
+  return S_OK;
+}
+
+STDMETHODIMP CFSFolder::GetNumberOfProperties(UInt32 *numProperties)
+{
+  *numProperties = ARRAY_SIZE(kProps);
+  if (!_flatMode)
+    (*numProperties)--;
+  return S_OK;
+}
+
+STDMETHODIMP CFSFolder::GetPropertyInfo IMP_IFolderFolder_GetProp(kProps)
+
+STDMETHODIMP CFSFolder::GetFolderProperty(PROPID propID, PROPVARIANT *value)
+{
+  COM_TRY_BEGIN
+  NWindows::NCOM::CPropVariant prop;
+  switch (propID)
+  {
+    case kpidType: prop = "FSFolder"; break;
+    case kpidPath: prop = fs2us(_path); break;
+  }
+  prop.Detach(value);
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CFSFolder::WasChanged(Int32 *wasChanged)
+{
+  bool wasChangedMain = false;
+
+  #ifdef _WIN32
+
+  for (;;)
+  {
+    if (!_findChangeNotification.IsHandleAllocated())
+      break;
+    DWORD waitResult = ::WaitForSingleObject(_findChangeNotification, 0);
+    if (waitResult != WAIT_OBJECT_0)
+      break;
+    _findChangeNotification.FindNext();
+    wasChangedMain = true;
+  }
+
+  #endif
+
+  *wasChanged = BoolToInt(wasChangedMain);
+  return S_OK;
+}
+ 
+STDMETHODIMP CFSFolder::Clone(IFolderFolder **resultFolder)
+{
+  CFSFolder *fsFolderSpec = new CFSFolder;
+  CMyComPtr<IFolderFolder> folderNew = fsFolderSpec;
+  fsFolderSpec->Init(_path);
+  *resultFolder = folderNew.Detach();
+  return S_OK;
+}
+
+HRESULT CFSFolder::GetItemsFullSize(const UInt32 *indices, UInt32 numItems, CFsFolderStat &stat)
+{
+  for (UInt32 i = 0; i < numItems; i++)
+  {
+    UInt32 index = indices[i];
+    /*
+    if (index >= Files.Size())
+    {
+      size += Streams[index - Files.Size()].Size;
+      // numFiles++;
+      continue;
+    }
+    */
+    const CDirItem &fi = Files[index];
+    if (fi.IsDir())
+    {
+      stat.Path = _path;
+      stat.Path += GetRelPath(fi);
+      RINOK(stat.Enumerate());
+      stat.NumFolders++;
+    }
+    else
+    {
+      stat.NumFiles++;
+      stat.Size += fi.Size;
+    }
+  }
+  return S_OK;
+}
+
+/*
+HRESULT CFSFolder::GetItemFullSize(unsigned index, UInt64 &size, IProgress *progress)
+{
+  if (index >= Files.Size())
+  {
+    size = Streams[index - Files.Size()].Size;
+    return S_OK;
+  }
+  const CDirItem &fi = Files[index];
+  if (fi.IsDir())
+  {
+    UInt64 numFolders = 0, numFiles = 0;
+    size = 0;
+    return GetFolderSize(_path + GetRelPath(fi), numFolders, numFiles, size, progress);
+  }
+  size = fi.Size;
+  return S_OK;
+}
+
+STDMETHODIMP CFSFolder::GetItemFullSize(UInt32 index, PROPVARIANT *value, IProgress *progress)
+{
+  NCOM::CPropVariant prop;
+  UInt64 size = 0;
+  HRESULT result = GetItemFullSize(index, size, progress);
+  prop = size;
+  prop.Detach(value);
+  return result;
+}
+*/
+
+STDMETHODIMP CFSFolder::CalcItemFullSize(UInt32 index, IProgress *progress)
+{
+  if (index >= (UInt32)Files.Size())
+    return S_OK;
+  CDirItem &fi = Files[index];
+  if (!fi.IsDir())
+    return S_OK;
+  CFsFolderStat stat(_path + GetRelPath(fi), progress);
+  RINOK(stat.Enumerate());
+  fi.Size = stat.Size;
+  fi.NumFolders = stat.NumFolders;
+  fi.NumFiles = stat.NumFiles;
+  fi.FolderStat_Defined = true;
+  return S_OK;
+}
+
+void CFSFolder::GetAbsPath(const wchar_t *name, FString &absPath)
+{
+  absPath.Empty();
+  if (!IsAbsolutePath(name))
+    absPath += _path;
+  absPath += us2fs(name);
+}
+
+STDMETHODIMP CFSFolder::CreateFolder(const wchar_t *name, IProgress * /* progress */)
+{
+  FString absPath;
+  GetAbsPath(name, absPath);
+  if (CreateDir(absPath))
+    return S_OK;
+  if (::GetLastError() == ERROR_ALREADY_EXISTS)
+    return ::GetLastError();
+  if (!CreateComplexDir(absPath))
+    return ::GetLastError();
+  return S_OK;
+}
+
+STDMETHODIMP CFSFolder::CreateFile(const wchar_t *name, IProgress * /* progress */)
+{
+  FString absPath;
+  GetAbsPath(name, absPath);
+  NIO::COutFile outFile;
+  if (!outFile.Create(absPath, false))
+    return ::GetLastError();
+  return S_OK;
+}
+
+STDMETHODIMP CFSFolder::Rename(UInt32 index, const wchar_t *newName, IProgress * /* progress */)
+{
+  if (index >= (UInt32)Files.Size())
+    return E_NOTIMPL;
+  const CDirItem &fi = Files[index];
+  // FString prefix;
+  // GetPrefix(fi, prefix);
+  FString fullPrefix = _path;
+  if (fi.Parent >= 0)
+    fullPrefix += Folders[fi.Parent];
+  if (!MyMoveFile(fullPrefix + fi.Name, fullPrefix + us2fs(newName)))
+    return GetLastError();
+  return S_OK;
+}
+
+STDMETHODIMP CFSFolder::Delete(const UInt32 *indices, UInt32 numItems,IProgress *progress)
+{
+  RINOK(progress->SetTotal(numItems));
+  // int prevDeletedFileIndex = -1;
+  for (UInt32 i = 0; i < numItems; i++)
+  {
+    // Sleep(200);
+    UInt32 index = indices[i];
+    bool result = true;
+    /*
+    if (index >= (UInt32)Files.Size())
+    {
+      const CAltStream &ss = Streams[index - (UInt32)Files.Size()];
+      if (prevDeletedFileIndex != ss.Parent)
+      {
+        const CDirItem &fi = Files[ss.Parent];
+        result = DeleteFileAlways(_path + GetRelPath(fi) + us2fs(ss.Name));
+      }
+    }
+    else
+    */
+    {
+      const CDirItem &fi = Files[index];
+      const FString fullPath = _path + GetRelPath(fi);
+      // prevDeletedFileIndex = index;
+      if (fi.IsDir())
+        result = RemoveDirWithSubItems(fullPath);
+      else
+        result = DeleteFileAlways(fullPath);
+    }
+    if (!result)
+      return GetLastError();
+    UInt64 completed = i;
+    RINOK(progress->SetCompleted(&completed));
+  }
+  return S_OK;
+}
+
+STDMETHODIMP CFSFolder::SetProperty(UInt32 index, PROPID propID,
+    const PROPVARIANT *value, IProgress * /* progress */)
+{
+  if (index >= (UInt32)Files.Size())
+    return E_INVALIDARG;
+  CDirItem &fi = Files[index];
+  if (fi.Parent >= 0)
+    return E_NOTIMPL;
+  switch (propID)
+  {
+    case kpidComment:
+    {
+      UString filename = fs2us(fi.Name);
+      filename.Trim();
+      if (value->vt == VT_EMPTY)
+        _comments.DeletePair(filename);
+      else if (value->vt == VT_BSTR)
+      {
+        CTextPair pair;
+        pair.ID = filename;
+        pair.ID.Trim();
+        pair.Value.SetFromBstr(value->bstrVal);
+        pair.Value.Trim();
+        if (pair.Value.IsEmpty())
+          _comments.DeletePair(filename);
+        else
+          _comments.AddPair(pair);
+      }
+      else
+        return E_INVALIDARG;
+      SaveComments();
+      break;
+    }
+    default:
+      return E_NOTIMPL;
+  }
+  return S_OK;
+}
+
+STDMETHODIMP CFSFolder::GetSystemIconIndex(UInt32 index, Int32 *iconIndex)
+{
+  if (index >= (UInt32)Files.Size())
+    return E_INVALIDARG;
+  const CDirItem &fi = Files[index];
+  *iconIndex = 0;
+  int iconIndexTemp;
+  if (GetRealIconIndex(_path + GetRelPath(fi), fi.Attrib, iconIndexTemp) != 0)
+  {
+    *iconIndex = iconIndexTemp;
+    return S_OK;
+  }
+  return GetLastError();
+}
+
+STDMETHODIMP CFSFolder::SetFlatMode(Int32 flatMode)
+{
+  _flatMode = IntToBool(flatMode);
+  return S_OK;
+}
+
+/*
+STDMETHODIMP CFSFolder::SetShowNtfsStreamsMode(Int32 showStreamsMode)
+{
+  _scanAltStreams = IntToBool(showStreamsMode);
+  return S_OK;
+}
+*/
+
+}
diff --git a/CPP/7zip/UI/FileManager/FSFolder.h b/CPP/7zip/UI/FileManager/FSFolder.h
new file mode 100644
index 0000000..fac1ef9
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FSFolder.h
@@ -0,0 +1,215 @@
+// FSFolder.h
+
+#ifndef __FS_FOLDER_H
+#define __FS_FOLDER_H
+
+#include "../../../Common/MyCom.h"
+#include "../../../Common/MyBuffer.h"
+
+#include "../../../Windows/FileFind.h"
+
+#include "../../Archive/IArchive.h"
+
+#include "IFolder.h"
+#include "TextPairs.h"
+
+namespace NFsFolder {
+
+class CFSFolder;
+
+#define FS_SHOW_LINKS_INFO
+
+struct CDirItem: public NWindows::NFile::NFind::CFileInfo
+{
+  #ifndef UNDER_CE
+  UInt64 PackSize;
+  #endif
+
+  #ifdef FS_SHOW_LINKS_INFO
+  UInt64 FileIndex;
+  UInt32 NumLinks;
+  bool FileInfo_Defined;
+  bool FileInfo_WasRequested;
+  #endif
+
+  #ifndef UNDER_CE
+  bool PackSize_Defined;
+  #endif
+
+  bool FolderStat_Defined;
+
+  #ifndef UNDER_CE
+  CByteBuffer Reparse;
+  #endif
+  
+  UInt64 NumFolders;
+  UInt64 NumFiles;
+  
+  int Parent;
+};
+
+/*
+struct CAltStream
+{
+  UInt64 Size;
+  UInt64 PackSize;
+  bool PackSize_Defined;
+  int Parent;
+  UString Name;
+};
+*/
+
+struct CFsFolderStat
+{
+  UInt64 NumFolders;
+  UInt64 NumFiles;
+  UInt64 Size;
+  IProgress *Progress;
+  FString Path;
+
+  CFsFolderStat(): NumFolders(0), NumFiles(0), Size(0), Progress(NULL) {}
+  CFsFolderStat(const FString &path, IProgress *progress = NULL):
+      NumFolders(0), NumFiles(0), Size(0), Progress(progress), Path(path) {}
+
+  HRESULT Enumerate();
+};
+
+class CFSFolder:
+  public IFolderFolder,
+  public IArchiveGetRawProps,
+  public IFolderCompare,
+  #ifdef USE_UNICODE_FSTRING
+  public IFolderGetItemName,
+  #endif
+  public IFolderWasChanged,
+  public IFolderOperations,
+  // public IFolderOperationsDeleteToRecycleBin,
+  public IFolderCalcItemFullSize,
+  public IFolderClone,
+  public IFolderGetSystemIconIndex,
+  public IFolderSetFlatMode,
+  // public IFolderSetShowNtfsStreamsMode,
+  public CMyUnknownImp
+{
+public:
+  MY_QUERYINTERFACE_BEGIN2(IFolderFolder)
+    MY_QUERYINTERFACE_ENTRY(IArchiveGetRawProps)
+    MY_QUERYINTERFACE_ENTRY(IFolderCompare)
+    #ifdef USE_UNICODE_FSTRING
+    MY_QUERYINTERFACE_ENTRY(IFolderGetItemName)
+    #endif
+    MY_QUERYINTERFACE_ENTRY(IFolderWasChanged)
+    // MY_QUERYINTERFACE_ENTRY(IFolderOperationsDeleteToRecycleBin)
+    MY_QUERYINTERFACE_ENTRY(IFolderOperations)
+    MY_QUERYINTERFACE_ENTRY(IFolderCalcItemFullSize)
+    MY_QUERYINTERFACE_ENTRY(IFolderClone)
+    MY_QUERYINTERFACE_ENTRY(IFolderGetSystemIconIndex)
+    MY_QUERYINTERFACE_ENTRY(IFolderSetFlatMode)
+    // MY_QUERYINTERFACE_ENTRY(IFolderSetShowNtfsStreamsMode)
+  MY_QUERYINTERFACE_END
+  MY_ADDREF_RELEASE
+
+
+  INTERFACE_FolderFolder(;)
+  INTERFACE_IArchiveGetRawProps(;)
+  INTERFACE_FolderOperations(;)
+
+  STDMETHOD_(Int32, CompareItems)(UInt32 index1, UInt32 index2, PROPID propID, Int32 propIsRaw);
+
+  #ifdef USE_UNICODE_FSTRING
+  INTERFACE_IFolderGetItemName(;)
+  #endif
+  STDMETHOD(WasChanged)(Int32 *wasChanged);
+  STDMETHOD(Clone)(IFolderFolder **resultFolder);
+  STDMETHOD(CalcItemFullSize)(UInt32 index, IProgress *progress);
+
+  STDMETHOD(SetFlatMode)(Int32 flatMode);
+  // STDMETHOD(SetShowNtfsStreamsMode)(Int32 showStreamsMode);
+
+  STDMETHOD(GetSystemIconIndex)(UInt32 index, Int32 *iconIndex);
+
+private:
+  FString _path;
+  
+  CObjectVector<CDirItem> Files;
+  FStringVector Folders;
+  // CObjectVector<CAltStream> Streams;
+  // CMyComPtr<IFolderFolder> _parentFolder;
+
+  bool _commentsAreLoaded;
+  CPairsStorage _comments;
+
+  // bool _scanAltStreams;
+  bool _flatMode;
+
+  #ifdef _WIN32
+  NWindows::NFile::NFind::CFindChangeNotification _findChangeNotification;
+  #endif
+
+  HRESULT GetItemsFullSize(const UInt32 *indices, UInt32 numItems, CFsFolderStat &stat);
+
+  HRESULT GetItemFullSize(unsigned index, UInt64 &size, IProgress *progress);
+  void GetAbsPath(const wchar_t *name, FString &absPath);
+  HRESULT BindToFolderSpec(CFSTR name, IFolderFolder **resultFolder);
+
+  bool LoadComments();
+  bool SaveComments();
+  HRESULT LoadSubItems(int dirItem, const FString &path);
+  
+  #ifdef FS_SHOW_LINKS_INFO
+  bool ReadFileInfo(CDirItem &di);
+  #endif
+
+public:
+  HRESULT Init(const FString &path /* , IFolderFolder *parentFolder */);
+  #if !defined(_WIN32) || defined(UNDER_CE)
+  HRESULT InitToRoot() { return Init((FString) FSTRING_PATH_SEPARATOR /* , NULL */); }
+  #endif
+
+  CFSFolder() : _flatMode(false)
+    // , _scanAltStreams(false)
+  {}
+
+  void GetFullPath(const CDirItem &item, FString &path) const
+  {
+    // FString prefix;
+    // GetPrefix(item, prefix);
+    path = _path;
+    if (item.Parent >= 0)
+      path += Folders[item.Parent];
+    path += item.Name;
+  }
+
+  // void GetPrefix(const CDirItem &item, FString &prefix) const;
+
+  FString GetRelPath(const CDirItem &item) const;
+
+  void Clear()
+  {
+    Files.Clear();
+    Folders.Clear();
+    // Streams.Clear();
+  }
+};
+
+struct CCopyStateIO
+{
+  IProgress *Progress;
+  UInt64 TotalSize;
+  UInt64 StartPos;
+  UInt64 CurrentSize;
+  bool DeleteSrcFile;
+
+  int ErrorFileIndex;
+  UString ErrorMessage;
+
+  CCopyStateIO(): TotalSize(0), StartPos(0), DeleteSrcFile(false) {}
+
+  HRESULT MyCopyFile(CFSTR inPath, CFSTR outPath, DWORD attrib = INVALID_FILE_ATTRIBUTES);
+};
+
+HRESULT SendLastErrorMessage(IFolderOperationsExtractCallback *callback, const FString &fileName);
+
+}
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/FSFolderCopy.cpp b/CPP/7zip/UI/FileManager/FSFolderCopy.cpp
new file mode 100644
index 0000000..ff444b3
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FSFolderCopy.cpp
@@ -0,0 +1,673 @@
+// FSFolderCopy.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyWindows.h"
+
+#include <WinBase.h>
+
+#include "../../../Common/Defs.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileName.h"
+
+#include "../../Common/FilePathAutoRename.h"
+
+#include "FSFolder.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+using namespace NName;
+using namespace NFind;
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NFsFolder {
+
+HRESULT CCopyStateIO::MyCopyFile(CFSTR inPath, CFSTR outPath, DWORD attrib)
+{
+  ErrorFileIndex = -1;
+  ErrorMessage.Empty();
+  CurrentSize = 0;
+
+  {
+    const size_t kBufSize = 1 << 16;
+    CByteArr buf(kBufSize);
+    
+    NIO::CInFile inFile;
+    NIO::COutFile outFile;
+    
+    if (!inFile.Open(inPath))
+    {
+      ErrorFileIndex = 0;
+      return S_OK;
+    }
+    
+    if (!outFile.Create(outPath, true))
+    {
+      ErrorFileIndex = 1;
+      return S_OK;
+    }
+    
+    for (;;)
+    {
+      UInt32 num;
+      if (!inFile.Read(buf, kBufSize, num))
+      {
+        ErrorFileIndex = 0;
+        return S_OK;
+      }
+      if (num == 0)
+        break;
+      
+      UInt32 written = 0;
+      if (!outFile.Write(buf, num, written))
+      {
+        ErrorFileIndex = 1;
+        return S_OK;
+      }
+      if (written != num)
+      {
+        ErrorMessage = "Write error";
+        return S_OK;
+      }
+      CurrentSize += num;
+      if (Progress)
+      {
+        UInt64 completed = StartPos + CurrentSize;
+        RINOK(Progress->SetCompleted(&completed));
+      }
+    }
+  }
+
+  if (attrib != INVALID_FILE_ATTRIBUTES)
+    SetFileAttrib(outPath, attrib);
+
+  if (DeleteSrcFile)
+  {
+    if (!DeleteFileAlways(inPath))
+    {
+      ErrorFileIndex = 0;
+      return S_OK;
+    }
+  }
+  
+  return S_OK;
+}
+
+
+/*
+static bool IsItWindows2000orHigher()
+{
+  OSVERSIONINFO versionInfo;
+  versionInfo.dwOSVersionInfoSize = sizeof(versionInfo);
+  if (!::GetVersionEx(&versionInfo))
+    return false;
+  return (versionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT) &&
+      (versionInfo.dwMajorVersion >= 5);
+}
+*/
+
+struct CProgressInfo
+{
+  UInt64 TotalSize;
+  UInt64 StartPos;
+  UInt64 FileSize;
+  IProgress *Progress;
+  HRESULT ProgressResult;
+
+  void Init() { ProgressResult = S_OK; }
+};
+
+#ifndef PROGRESS_CONTINUE
+
+#define PROGRESS_CONTINUE 0
+#define PROGRESS_CANCEL 1
+
+#define COPY_FILE_FAIL_IF_EXISTS 0x00000001
+
+typedef
+DWORD
+(WINAPI* LPPROGRESS_ROUTINE)(
+    LARGE_INTEGER TotalFileSize,
+    LARGE_INTEGER TotalBytesTransferred,
+    LARGE_INTEGER StreamSize,
+    LARGE_INTEGER StreamBytesTransferred,
+    DWORD dwStreamNumber,
+    DWORD dwCallbackReason,
+    HANDLE hSourceFile,
+    HANDLE hDestinationFile,
+    LPVOID lpData
+    );
+
+#endif
+
+static DWORD CALLBACK CopyProgressRoutine(
+  LARGE_INTEGER TotalFileSize,          // file size
+  LARGE_INTEGER TotalBytesTransferred,  // bytes transferred
+  LARGE_INTEGER /* StreamSize */,             // bytes in stream
+  LARGE_INTEGER /* StreamBytesTransferred */, // bytes transferred for stream
+  DWORD /* dwStreamNumber */,                 // current stream
+  DWORD /* dwCallbackReason */,               // callback reason
+  HANDLE /* hSourceFile */,                   // handle to source file
+  HANDLE /* hDestinationFile */,              // handle to destination file
+  LPVOID lpData                         // from CopyFileEx
+)
+{
+  // StreamSize = StreamSize;
+  // StreamBytesTransferred = StreamBytesTransferred;
+  // dwStreamNumber = dwStreamNumber;
+  // dwCallbackReason = dwCallbackReason;
+
+  CProgressInfo &pi = *(CProgressInfo *)lpData;
+
+  if ((UInt64)TotalFileSize.QuadPart > pi.FileSize)
+  {
+    pi.TotalSize += (UInt64)TotalFileSize.QuadPart - pi.FileSize;
+    pi.FileSize = (UInt64)TotalFileSize.QuadPart;
+    pi.ProgressResult = pi.Progress->SetTotal(pi.TotalSize);
+  }
+  UInt64 completed = pi.StartPos + TotalBytesTransferred.QuadPart;
+  pi.ProgressResult = pi.Progress->SetCompleted(&completed);
+  return (pi.ProgressResult == S_OK ? PROGRESS_CONTINUE : PROGRESS_CANCEL);
+}
+
+typedef BOOL (WINAPI * Func_CopyFileExA)(
+    IN LPCSTR lpExistingFileName,
+    IN LPCSTR lpNewFileName,
+    IN LPPROGRESS_ROUTINE lpProgressRoutine OPTIONAL,
+    IN LPVOID lpData OPTIONAL,
+    IN LPBOOL pbCancel OPTIONAL,
+    IN DWORD dwCopyFlags
+    );
+
+typedef BOOL (WINAPI * Func_CopyFileExW)(
+    IN LPCWSTR lpExistingFileName,
+    IN LPCWSTR lpNewFileName,
+    IN LPPROGRESS_ROUTINE lpProgressRoutine OPTIONAL,
+    IN LPVOID lpData OPTIONAL,
+    IN LPBOOL pbCancel OPTIONAL,
+    IN DWORD dwCopyFlags
+    );
+
+typedef BOOL (WINAPI * Func_MoveFileWithProgressW)(
+    IN LPCWSTR lpExistingFileName,
+    IN LPCWSTR lpNewFileName,
+    IN LPPROGRESS_ROUTINE lpProgressRoutine OPTIONAL,
+    IN LPVOID lpData OPTIONAL,
+    IN DWORD dwFlags
+    );
+
+struct CCopyState
+{
+  CProgressInfo ProgressInfo;
+  IFolderOperationsExtractCallback *Callback;
+  bool MoveMode;
+  bool UseReadWriteMode;
+
+  Func_CopyFileExW my_CopyFileExW;
+  #ifndef UNDER_CE
+  Func_MoveFileWithProgressW my_MoveFileWithProgressW;
+  #endif
+  #ifndef _UNICODE
+  Func_CopyFileExA my_CopyFileExA;
+  #endif
+
+  void Prepare();
+  bool CopyFile_NT(const wchar_t *oldFile, const wchar_t *newFile);
+  bool CopyFile_Sys(CFSTR oldFile, CFSTR newFile);
+  bool MoveFile_Sys(CFSTR oldFile, CFSTR newFile);
+
+  HRESULT CallProgress();
+
+  bool IsCallbackProgressError() { return ProgressInfo.ProgressResult != S_OK; }
+};
+
+HRESULT CCopyState::CallProgress()
+{
+  return ProgressInfo.Progress->SetCompleted(&ProgressInfo.StartPos);
+}
+
+void CCopyState::Prepare()
+{
+  my_CopyFileExW = NULL;
+  #ifndef UNDER_CE
+  my_MoveFileWithProgressW = NULL;
+  #endif
+  #ifndef _UNICODE
+  my_CopyFileExA = NULL;
+  if (!g_IsNT)
+  {
+    my_CopyFileExA = (Func_CopyFileExA)::GetProcAddress(::GetModuleHandleA("kernel32.dll"), "CopyFileExA");
+  }
+  else
+  #endif
+  {
+    HMODULE module = ::GetModuleHandleW(
+      #ifdef UNDER_CE
+        L"coredll.dll"
+      #else
+        L"kernel32.dll"
+      #endif
+        );
+    my_CopyFileExW = (Func_CopyFileExW)My_GetProcAddress(module, "CopyFileExW");
+    #ifndef UNDER_CE
+    my_MoveFileWithProgressW = (Func_MoveFileWithProgressW)My_GetProcAddress(module, "MoveFileWithProgressW");
+    #endif
+  }
+}
+
+/* WinXP-64:
+  CopyFileW(fromFile, toFile:altStream)
+    OK                       - there are NO alt streams in fromFile
+    ERROR_INVALID_PARAMETER  - there are    alt streams in fromFile
+*/
+
+bool CCopyState::CopyFile_NT(const wchar_t *oldFile, const wchar_t *newFile)
+{
+  BOOL cancelFlag = FALSE;
+  if (my_CopyFileExW)
+    return BOOLToBool(my_CopyFileExW(oldFile, newFile, CopyProgressRoutine,
+        &ProgressInfo, &cancelFlag, COPY_FILE_FAIL_IF_EXISTS));
+  return BOOLToBool(::CopyFileW(oldFile, newFile, TRUE));
+}
+
+bool CCopyState::CopyFile_Sys(CFSTR oldFile, CFSTR newFile)
+{
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    if (my_CopyFileExA)
+    {
+      BOOL cancelFlag = FALSE;
+      if (my_CopyFileExA(fs2fas(oldFile), fs2fas(newFile),
+          CopyProgressRoutine, &ProgressInfo, &cancelFlag, COPY_FILE_FAIL_IF_EXISTS))
+        return true;
+      if (::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
+        return false;
+    }
+    return BOOLToBool(::CopyFile(fs2fas(oldFile), fs2fas(newFile), TRUE));
+  }
+  else
+  #endif
+  {
+    IF_USE_MAIN_PATH_2(oldFile, newFile)
+    {
+      if (CopyFile_NT(fs2us(oldFile), fs2us(newFile)))
+        return true;
+    }
+    #ifdef WIN_LONG_PATH
+    if (USE_SUPER_PATH_2)
+    {
+      if (IsCallbackProgressError())
+        return false;
+      UString superPathOld, superPathNew;
+      if (!GetSuperPaths(oldFile, newFile, superPathOld, superPathNew, USE_MAIN_PATH_2))
+        return false;
+      if (CopyFile_NT(superPathOld, superPathNew))
+        return true;
+    }
+    #endif
+    return false;
+  }
+}
+
+bool CCopyState::MoveFile_Sys(CFSTR oldFile, CFSTR newFile)
+{
+  #ifndef UNDER_CE
+  // if (IsItWindows2000orHigher())
+  // {
+    if (my_MoveFileWithProgressW)
+    {
+      IF_USE_MAIN_PATH_2(oldFile, newFile)
+      {
+        if (my_MoveFileWithProgressW(fs2us(oldFile), fs2us(newFile), CopyProgressRoutine,
+            &ProgressInfo, MOVEFILE_COPY_ALLOWED))
+          return true;
+      }
+      #ifdef WIN_LONG_PATH
+      if ((!(USE_MAIN_PATH_2) || ::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED) && USE_SUPER_PATH_2)
+      {
+        if (IsCallbackProgressError())
+          return false;
+        UString superPathOld, superPathNew;
+        if (!GetSuperPaths(oldFile, newFile, superPathOld, superPathNew, USE_MAIN_PATH_2))
+          return false;
+        if (my_MoveFileWithProgressW(superPathOld, superPathNew, CopyProgressRoutine,
+            &ProgressInfo, MOVEFILE_COPY_ALLOWED))
+          return true;
+      }
+      #endif
+      if (::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
+        return false;
+    }
+  // }
+  // else
+  #endif
+    return MyMoveFile(oldFile, newFile);
+}
+
+static HRESULT SendMessageError(IFolderOperationsExtractCallback *callback,
+    const wchar_t *message, const FString &fileName)
+{
+  UString s = message;
+  s += " : ";
+  s += fs2us(fileName);
+  return callback->ShowMessage(s);
+}
+
+static HRESULT SendMessageError(IFolderOperationsExtractCallback *callback,
+    const char *message, const FString &fileName)
+{
+  return SendMessageError(callback, MultiByteToUnicodeString(message), fileName);
+}
+
+static DWORD Return_LastError_or_FAIL()
+{
+  DWORD errorCode = GetLastError();
+  if (errorCode == 0)
+    errorCode = (DWORD)E_FAIL;
+  return errorCode;
+}
+
+static UString GetLastErrorMessage()
+{
+  return NError::MyFormatMessage(Return_LastError_or_FAIL());
+}
+
+HRESULT SendLastErrorMessage(IFolderOperationsExtractCallback *callback, const FString &fileName)
+{
+  return SendMessageError(callback, GetLastErrorMessage(), fileName);
+}
+
+static HRESULT CopyFile_Ask(
+    CCopyState &state,
+    const FString &srcPath,
+    const CFileInfo &srcFileInfo,
+    const FString &destPath)
+{
+  if (CompareFileNames(destPath, srcPath) == 0)
+  {
+    RINOK(SendMessageError(state.Callback,
+        state.MoveMode ?
+          "Cannot move file onto itself" :
+          "Cannot copy file onto itself"
+        , destPath));
+    return E_ABORT;
+  }
+
+  Int32 writeAskResult;
+  CMyComBSTR destPathResult;
+  RINOK(state.Callback->AskWrite(
+      fs2us(srcPath),
+      BoolToInt(false),
+      &srcFileInfo.MTime, &srcFileInfo.Size,
+      fs2us(destPath),
+      &destPathResult,
+      &writeAskResult));
+  
+  if (IntToBool(writeAskResult))
+  {
+    FString destPathNew = us2fs((LPCOLESTR)destPathResult);
+    RINOK(state.Callback->SetCurrentFilePath(fs2us(srcPath)));
+
+    if (state.UseReadWriteMode)
+    {
+      NFsFolder::CCopyStateIO state2;
+      state2.Progress = state.Callback;
+      state2.DeleteSrcFile = state.MoveMode;
+      state2.TotalSize = state.ProgressInfo.TotalSize;
+      state2.StartPos = state.ProgressInfo.StartPos;
+
+      RINOK(state2.MyCopyFile(srcPath, destPathNew, srcFileInfo.Attrib));
+      
+      if (state2.ErrorFileIndex >= 0)
+      {
+        if (state2.ErrorMessage.IsEmpty())
+          state2.ErrorMessage = GetLastErrorMessage();
+        FString errorName;
+        if (state2.ErrorFileIndex == 0)
+          errorName = srcPath;
+        else
+          errorName = destPathNew;
+        RINOK(SendMessageError(state.Callback, state2.ErrorMessage, errorName));
+        return E_ABORT;
+      }
+      state.ProgressInfo.StartPos += state2.CurrentSize;
+    }
+    else
+    {
+      state.ProgressInfo.FileSize = srcFileInfo.Size;
+      bool res;
+      if (state.MoveMode)
+        res = state.MoveFile_Sys(srcPath, destPathNew);
+      else
+        res = state.CopyFile_Sys(srcPath, destPathNew);
+      RINOK(state.ProgressInfo.ProgressResult);
+      if (!res)
+      {
+        // GetLastError() is ERROR_REQUEST_ABORTED in case of PROGRESS_CANCEL.
+        RINOK(SendMessageError(state.Callback, GetLastErrorMessage(), destPathNew));
+        return E_ABORT;
+      }
+      state.ProgressInfo.StartPos += state.ProgressInfo.FileSize;
+    }
+  }
+  else
+  {
+    if (state.ProgressInfo.TotalSize >= srcFileInfo.Size)
+    {
+      state.ProgressInfo.TotalSize -= srcFileInfo.Size;
+      RINOK(state.ProgressInfo.Progress->SetTotal(state.ProgressInfo.TotalSize));
+    }
+  }
+  return state.CallProgress();
+}
+
+static FString CombinePath(const FString &folderPath, const FString &fileName)
+{
+  FString s (folderPath);
+  s.Add_PathSepar(); // FCHAR_PATH_SEPARATOR
+  s += fileName;
+  return s;
+}
+
+static bool IsDestChild(const FString &src, const FString &dest)
+{
+  unsigned len = src.Len();
+  if (dest.Len() < len)
+    return false;
+  if (dest.Len() != len && dest[len] != FCHAR_PATH_SEPARATOR)
+    return false;
+  return CompareFileNames(dest.Left(len), src) == 0;
+}
+
+static HRESULT CopyFolder(
+    CCopyState &state,
+    const FString &srcPath,   // without TAIL separator
+    const FString &destPath)  // without TAIL separator
+{
+  RINOK(state.CallProgress());
+
+  if (IsDestChild(srcPath, destPath))
+  {
+    RINOK(SendMessageError(state.Callback,
+        state.MoveMode ?
+          "Cannot copy folder onto itself" :
+          "Cannot move folder onto itself"
+        , destPath));
+    return E_ABORT;
+  }
+
+  if (state.MoveMode)
+  {
+    if (state.MoveFile_Sys(srcPath, destPath))
+      return S_OK;
+
+    // MSDN: MoveFile() fails for dirs on different volumes.
+  }
+
+  if (!CreateComplexDir(destPath))
+  {
+    RINOK(SendMessageError(state.Callback, "Cannot create folder", destPath));
+    return E_ABORT;
+  }
+
+  CEnumerator enumerator;
+  enumerator.SetDirPrefix(CombinePath(srcPath, FString()));
+  
+  for (;;)
+  {
+    NFind::CFileInfo fi;
+    bool found;
+    if (!enumerator.Next(fi, found))
+    {
+      SendLastErrorMessage(state.Callback, srcPath);
+      return S_OK;
+    }
+    if (!found)
+      break;
+    const FString srcPath2 = CombinePath(srcPath, fi.Name);
+    const FString destPath2 = CombinePath(destPath, fi.Name);
+    if (fi.IsDir())
+    {
+      RINOK(CopyFolder(state, srcPath2, destPath2))
+    }
+    else
+    {
+      RINOK(CopyFile_Ask(state, srcPath2, fi, destPath2));
+    }
+  }
+
+  if (state.MoveMode)
+  {
+    if (!RemoveDir(srcPath))
+    {
+      RINOK(SendMessageError(state.Callback, "Cannot remove folder", srcPath));
+      return E_ABORT;
+    }
+  }
+  
+  return S_OK;
+}
+
+STDMETHODIMP CFSFolder::CopyTo(Int32 moveMode, const UInt32 *indices, UInt32 numItems,
+    Int32 /* includeAltStreams */, Int32 /* replaceAltStreamColon */,
+    const wchar_t *path, IFolderOperationsExtractCallback *callback)
+{
+  if (numItems == 0)
+    return S_OK;
+
+  FString destPath = us2fs(path);
+  if (destPath.IsEmpty())
+    return E_INVALIDARG;
+
+  bool isAltDest = NName::IsAltPathPrefix(destPath);
+  bool isDirectPath = (!isAltDest && !IsPathSepar(destPath.Back()));
+
+  if (isDirectPath)
+  {
+    if (numItems > 1)
+      return E_INVALIDARG;
+  }
+
+  CFsFolderStat stat;
+  stat.Progress = callback;
+  RINOK(GetItemsFullSize(indices, numItems, stat));
+
+  if (stat.NumFolders != 0 && isAltDest)
+    return E_NOTIMPL;
+
+  RINOK(callback->SetTotal(stat.Size));
+  RINOK(callback->SetNumFiles(stat.NumFiles));
+
+  UInt64 completedSize = 0;
+  RINOK(callback->SetCompleted(&completedSize));
+
+  CCopyState state;
+  state.ProgressInfo.TotalSize = stat.Size;
+  state.ProgressInfo.StartPos = 0;
+  state.ProgressInfo.Progress = callback;
+  state.ProgressInfo.Init();
+  state.Callback = callback;
+  state.MoveMode = IntToBool(moveMode);
+  state.UseReadWriteMode = isAltDest;
+  state.Prepare();
+
+  for (UInt32 i = 0; i < numItems; i++)
+  {
+    UInt32 index = indices[i];
+    if (index >= (UInt32)Files.Size())
+      continue;
+    const CDirItem &fi = Files[index];
+    FString destPath2 = destPath;
+    if (!isDirectPath)
+      destPath2 += fi.Name;
+    FString srcPath;
+    GetFullPath(fi, srcPath);
+  
+    if (fi.IsDir())
+    {
+      RINOK(CopyFolder(state, srcPath, destPath2));
+    }
+    else
+    {
+      RINOK(CopyFile_Ask(state, srcPath, fi, destPath2));
+    }
+  }
+  return S_OK;
+}
+
+STDMETHODIMP CFSFolder::CopyFrom(Int32 /* moveMode */, const wchar_t * /* fromFolderPath */,
+    const wchar_t * const * /* itemsPaths */, UInt32 /* numItems */, IProgress * /* progress */)
+{
+  /*
+  UInt64 numFolders, numFiles, totalSize;
+  numFiles = numFolders = totalSize = 0;
+  UInt32 i;
+  for (i = 0; i < numItems; i++)
+  {
+    UString path = (UString)fromFolderPath + itemsPaths[i];
+
+    CFileInfo fi;
+    if (!FindFile(path, fi))
+      return ::GetLastError();
+    if (fi.IsDir())
+    {
+      UInt64 subFolders, subFiles, subSize;
+      RINOK(GetFolderSize(CombinePath(path, fi.Name), subFolders, subFiles, subSize, progress));
+      numFolders += subFolders;
+      numFolders++;
+      numFiles += subFiles;
+      totalSize += subSize;
+    }
+    else
+    {
+      numFiles++;
+      totalSize += fi.Size;
+    }
+  }
+  RINOK(progress->SetTotal(totalSize));
+  RINOK(callback->SetNumFiles(numFiles));
+  for (i = 0; i < numItems; i++)
+  {
+    UString path = (UString)fromFolderPath + itemsPaths[i];
+  }
+  return S_OK;
+  */
+  return E_NOTIMPL;
+}
+
+STDMETHODIMP CFSFolder::CopyFromFile(UInt32 /* index */, const wchar_t * /* fullFilePath */, IProgress * /* progress */)
+{
+  return E_NOTIMPL;
+}
+
+}
diff --git a/CPP/7zip/UI/FileManager/FileFolderPluginOpen.cpp b/CPP/7zip/UI/FileManager/FileFolderPluginOpen.cpp
new file mode 100644
index 0000000..a7873fe
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FileFolderPluginOpen.cpp
@@ -0,0 +1,357 @@
+// FileFolderPluginOpen.cpp
+
+#include "StdAfx.h"
+
+#include "resource.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/Thread.h"
+
+#include "../Agent/Agent.h"
+#include "../GUI/ExtractRes.h"
+
+#include "FileFolderPluginOpen.h"
+#include "FormatUtils.h"
+#include "LangUtils.h"
+#include "OpenCallback.h"
+#include "PluginLoader.h"
+#include "PropertyName.h"
+#include "RegistryPlugins.h"
+
+using namespace NWindows;
+
+struct CThreadArchiveOpen
+{
+  UString Path;
+  UString ArcFormat;
+  CMyComPtr<IInStream> InStream;
+  CMyComPtr<IFolderManager> FolderManager;
+  CMyComPtr<IProgress> OpenCallback;
+  COpenArchiveCallback *OpenCallbackSpec;
+
+  CMyComPtr<IFolderFolder> Folder;
+  HRESULT Result;
+
+  void Process()
+  {
+    try
+    {
+      CProgressCloser closer(OpenCallbackSpec->ProgressDialog);
+      Result = FolderManager->OpenFolderFile(InStream, Path, ArcFormat, &Folder, OpenCallback);
+    }
+    catch(...) { Result = E_FAIL; }
+  }
+  
+  static THREAD_FUNC_DECL MyThreadFunction(void *param)
+  {
+    ((CThreadArchiveOpen *)param)->Process();
+    return 0;
+  }
+};
+
+/*
+static int FindPlugin(const CObjectVector<CPluginInfo> &plugins, const UString &pluginName)
+{
+  for (int i = 0; i < plugins.Size(); i++)
+    if (plugins[i].Name.CompareNoCase(pluginName) == 0)
+      return i;
+  return -1;
+}
+*/
+
+static void SplitNameToPureNameAndExtension(const FString &fullName,
+    FString &pureName, FString &extensionDelimiter, FString &extension)
+{
+  int index = fullName.ReverseFind_Dot();
+  if (index < 0)
+  {
+    pureName = fullName;
+    extensionDelimiter.Empty();
+    extension.Empty();
+  }
+  else
+  {
+    pureName.SetFrom(fullName, index);
+    extensionDelimiter = '.';
+    extension = fullName.Ptr((unsigned)index + 1);
+  }
+}
+
+
+struct CArcLevelInfo
+{
+  UString Error;
+  UString Path;
+  UString Type;
+  UString ErrorType;
+  UString ErrorFlags;
+};
+
+
+struct CArcLevelsInfo
+{
+  CObjectVector<CArcLevelInfo> Levels; // LastLevel Is NON-OPEN
+};
+
+
+UString GetOpenArcErrorMessage(UInt32 errorFlags);
+
+
+static void GetFolderLevels(CMyComPtr<IFolderFolder> &folder, CArcLevelsInfo &levels)
+{
+  levels.Levels.Clear();
+
+  CMyComPtr<IGetFolderArcProps> getFolderArcProps;
+  folder.QueryInterface(IID_IGetFolderArcProps, &getFolderArcProps);
+  
+  if (!getFolderArcProps)
+    return;
+  CMyComPtr<IFolderArcProps> arcProps;
+  getFolderArcProps->GetFolderArcProps(&arcProps);
+  if (!arcProps)
+    return;
+
+  UInt32 numLevels;
+  if (arcProps->GetArcNumLevels(&numLevels) != S_OK)
+    numLevels = 0;
+  
+  for (UInt32 level = 0; level <= numLevels; level++)
+  {
+    const PROPID propIDs[] = { kpidError, kpidPath, kpidType, kpidErrorType };
+
+    CArcLevelInfo lev;
+    
+    for (Int32 i = 0; i < 4; i++)
+    {
+      CMyComBSTR name;
+      NCOM::CPropVariant prop;
+      if (arcProps->GetArcProp(level, propIDs[i], &prop) != S_OK)
+        continue;
+      if (prop.vt != VT_EMPTY)
+      {
+        UString *s = NULL;
+        switch (propIDs[i])
+        {
+          case kpidError: s = &lev.Error; break;
+          case kpidPath: s = &lev.Path; break;
+          case kpidType: s = &lev.Type; break;
+          case kpidErrorType: s = &lev.ErrorType; break;
+        }
+        *s = (prop.vt == VT_BSTR) ? prop.bstrVal : L"?";
+      }
+    }
+
+    {
+      NCOM::CPropVariant prop;
+      if (arcProps->GetArcProp(level, kpidErrorFlags, &prop) == S_OK)
+      {
+        UInt32 flags = GetOpenArcErrorFlags(prop);
+        if (flags != 0)
+          lev.ErrorFlags = GetOpenArcErrorMessage(flags);
+      }
+    }
+
+    levels.Levels.Add(lev);
+  }
+}
+    
+static UString GetBracedType(const wchar_t *type)
+{
+  UString s ('[');
+  s += type;
+  s += ']';
+  return s;
+}
+
+static void GetFolderError(CMyComPtr<IFolderFolder> &folder, UString &open_Errors, UString &nonOpen_Errors)
+{
+  CArcLevelsInfo levs;
+  GetFolderLevels(folder, levs);
+  open_Errors.Empty();
+  nonOpen_Errors.Empty();
+
+  FOR_VECTOR (i, levs.Levels)
+  {
+    bool isNonOpenLevel = (i == 0);
+    const CArcLevelInfo &lev = levs.Levels[levs.Levels.Size() - 1 - i];
+
+    UString m;
+    
+    if (!lev.ErrorType.IsEmpty())
+    {
+      m = MyFormatNew(IDS_CANT_OPEN_AS_TYPE, GetBracedType(lev.ErrorType));
+      if (!isNonOpenLevel)
+      {
+        m.Add_LF();
+        m += MyFormatNew(IDS_IS_OPEN_AS_TYPE, GetBracedType(lev.Type));
+      }
+    }
+
+    if (!lev.Error.IsEmpty())
+    {
+      if (!m.IsEmpty())
+        m.Add_LF();
+      m += GetBracedType(lev.Type);
+      m += " : ";
+      m += GetNameOfProperty(kpidError, L"Error");
+      m += " : ";
+      m += lev.Error;
+    }
+
+    if (!lev.ErrorFlags.IsEmpty())
+    {
+      if (!m.IsEmpty())
+        m.Add_LF();
+      m += GetNameOfProperty(kpidErrorFlags, L"Errors");
+      m += ": ";
+      m += lev.ErrorFlags;
+    }
+    
+    if (!m.IsEmpty())
+    {
+      if (isNonOpenLevel)
+      {
+        UString &s = nonOpen_Errors;
+        s += lev.Path;
+        s.Add_LF();
+        s += m;
+      }
+      else
+      {
+        UString &s = open_Errors;
+        if (!s.IsEmpty())
+          s += "--------------------\n";
+        s += lev.Path;
+        s.Add_LF();
+        s += m;
+      }
+    }
+  }
+}
+
+
+HRESULT CFfpOpen::OpenFileFolderPlugin(IInStream *inStream,
+    const FString &path, const UString &arcFormat, HWND parentWindow)
+{
+  CObjectVector<CPluginInfo> plugins;
+  ReadFileFolderPluginInfoList(plugins);
+
+  FString extension, name, pureName, dot;
+
+  int slashPos = path.ReverseFind_PathSepar();
+  FString dirPrefix;
+  FString fileName;
+  if (slashPos >= 0)
+  {
+    dirPrefix.SetFrom(path, (unsigned)(slashPos + 1));
+    fileName = path.Ptr((unsigned)(slashPos + 1));
+  }
+  else
+    fileName = path;
+
+  SplitNameToPureNameAndExtension(fileName, pureName, dot, extension);
+
+  /*
+  if (!extension.IsEmpty())
+  {
+    CExtInfo extInfo;
+    if (ReadInternalAssociation(extension, extInfo))
+    {
+      for (int i = extInfo.Plugins.Size() - 1; i >= 0; i--)
+      {
+        int pluginIndex = FindPlugin(plugins, extInfo.Plugins[i]);
+        if (pluginIndex >= 0)
+        {
+          const CPluginInfo plugin = plugins[pluginIndex];
+          plugins.Delete(pluginIndex);
+          plugins.Insert(0, plugin);
+        }
+      }
+    }
+  }
+  */
+
+  ErrorMessage.Empty();
+
+  FOR_VECTOR (i, plugins)
+  {
+    const CPluginInfo &plugin = plugins[i];
+    if (!plugin.ClassIDDefined)
+      continue;
+    CPluginLibrary library;
+
+    CThreadArchiveOpen t;
+
+    if (plugin.FilePath.IsEmpty())
+      t.FolderManager = new CArchiveFolderManager;
+    else if (library.LoadAndCreateManager(plugin.FilePath, plugin.ClassID, &t.FolderManager) != S_OK)
+      continue;
+
+    t.OpenCallbackSpec = new COpenArchiveCallback;
+    t.OpenCallback = t.OpenCallbackSpec;
+    t.OpenCallbackSpec->PasswordIsDefined = Encrypted;
+    t.OpenCallbackSpec->Password = Password;
+    t.OpenCallbackSpec->ParentWindow = parentWindow;
+
+    if (inStream)
+      t.OpenCallbackSpec->SetSubArchiveName(fs2us(fileName));
+    else
+    {
+      RINOK(t.OpenCallbackSpec->LoadFileInfo2(dirPrefix, fileName));
+    }
+
+    t.InStream = inStream;
+    t.Path = fs2us(path);
+    t.ArcFormat = arcFormat;
+
+    const UString progressTitle = LangString(IDS_OPENNING);
+    {
+      CProgressDialog &pd = t.OpenCallbackSpec->ProgressDialog;
+      pd.MainWindow = parentWindow;
+      pd.MainTitle = "7-Zip"; // LangString(IDS_APP_TITLE);
+      pd.MainAddTitle = progressTitle + L' ';
+      pd.WaitMode = true;
+    }
+
+    {
+      NWindows::CThread thread;
+      RINOK(thread.Create(CThreadArchiveOpen::MyThreadFunction, &t));
+      t.OpenCallbackSpec->StartProgressDialog(progressTitle, thread);
+    }
+
+    if (t.Result != S_FALSE && t.Result != S_OK)
+      return t.Result;
+
+    if (t.Folder)
+    {
+      UString open_Errors, nonOpen_Errors;
+      GetFolderError(t.Folder, open_Errors, nonOpen_Errors);
+      if (!nonOpen_Errors.IsEmpty())
+      {
+        ErrorMessage = nonOpen_Errors;
+        // if (t.Result != S_OK) return t.Result;
+        /* if there are good open leves, and non0open level,
+           we could force error as critical error and return error here
+           but it's better to allow to open such rachives */
+        // return S_FALSE;
+      }
+    }
+
+    // if (openCallbackSpec->PasswordWasAsked)
+    {
+      Encrypted = t.OpenCallbackSpec->PasswordIsDefined;
+      Password = t.OpenCallbackSpec->Password;
+    }
+
+    if (t.Result == S_OK)
+    {
+      Library.Attach(library.Detach());
+      // Folder.Attach(t.Folder.Detach());
+      Folder = t.Folder;
+    }
+    
+    return t.Result;
+  }
+
+  return S_FALSE;
+}
diff --git a/CPP/7zip/UI/FileManager/FileFolderPluginOpen.h b/CPP/7zip/UI/FileManager/FileFolderPluginOpen.h
new file mode 100644
index 0000000..a1f2f10
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FileFolderPluginOpen.h
@@ -0,0 +1,27 @@
+// FileFolderPluginOpen.h
+
+#ifndef __FILE_FOLDER_PLUGIN_OPEN_H
+#define __FILE_FOLDER_PLUGIN_OPEN_H
+
+#include "../../../Windows/DLL.h"
+
+struct CFfpOpen
+{
+  CLASS_NO_COPY(CFfpOpen)
+public:
+  // out:
+  bool Encrypted;
+  UString Password;
+
+  NWindows::NDLL::CLibrary Library;
+  CMyComPtr<IFolderFolder> Folder;
+  UString ErrorMessage;
+
+  CFfpOpen(): Encrypted (false) {}
+
+  HRESULT OpenFileFolderPlugin(IInStream *inStream,
+      const FString &path, const UString &arcFormat, HWND parentWindow);
+};
+
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/FilePlugins.cpp b/CPP/7zip/UI/FileManager/FilePlugins.cpp
new file mode 100644
index 0000000..4600030
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FilePlugins.cpp
@@ -0,0 +1,69 @@
+// FilePlugins.cpp
+
+#include "StdAfx.h"
+
+#include "../Agent/Agent.h"
+
+#include "FilePlugins.h"
+#include "PluginLoader.h"
+#include "StringUtils.h"
+
+int CExtDatabase::FindExt(const UString &ext)
+{
+  FOR_VECTOR (i, Exts)
+    if (Exts[i].Ext.IsEqualTo_NoCase(ext))
+      return i;
+  return -1;
+}
+
+void CExtDatabase::Read()
+{
+  ReadFileFolderPluginInfoList(Plugins);
+  FOR_VECTOR (pluginIndex, Plugins)
+  {
+    const CPluginInfo &plugin = Plugins[pluginIndex];
+
+    CPluginLibrary pluginLib;
+    CMyComPtr<IFolderManager> folderManager;
+
+    if (plugin.FilePath.IsEmpty())
+      folderManager = new CArchiveFolderManager;
+    else if (pluginLib.LoadAndCreateManager(plugin.FilePath, plugin.ClassID, &folderManager) != S_OK)
+      continue;
+    CMyComBSTR extBSTR;
+    if (folderManager->GetExtensions(&extBSTR) != S_OK)
+      return;
+    UStringVector exts;
+    SplitString((const wchar_t *)extBSTR, exts);
+    FOR_VECTOR (i, exts)
+    {
+      const UString &ext = exts[i];
+      #ifdef UNDER_CE
+      if (ext == L"cab")
+        continue;
+      #endif
+
+      Int32 iconIndex;
+      CMyComBSTR iconPath;
+      CPluginToIcon plugPair;
+      plugPair.PluginIndex = pluginIndex;
+      if (folderManager->GetIconPath(ext, &iconPath, &iconIndex) == S_OK)
+        if (iconPath != 0)
+        {
+          plugPair.IconPath = (const wchar_t *)iconPath;
+          plugPair.IconIndex = iconIndex;
+        }
+
+      int index = FindExt(ext);
+      if (index >= 0)
+        Exts[index].Plugins.Add(plugPair);
+      else
+      {
+        CExtPlugins extInfo;
+        extInfo.Plugins.Add(plugPair);
+        extInfo.Ext = ext;
+        Exts.Add(extInfo);
+      }
+    }
+  }
+}
diff --git a/CPP/7zip/UI/FileManager/FilePlugins.h b/CPP/7zip/UI/FileManager/FilePlugins.h
new file mode 100644
index 0000000..43b05f9
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FilePlugins.h
@@ -0,0 +1,33 @@
+// FilePlugins.h
+
+#ifndef __FILE_PLUGINS_H
+#define __FILE_PLUGINS_H
+
+#include "RegistryPlugins.h"
+
+struct CPluginToIcon
+{
+  int PluginIndex;
+  UString IconPath;
+  int IconIndex;
+  
+  CPluginToIcon(): IconIndex(-1) {}
+};
+
+struct CExtPlugins
+{
+  UString Ext;
+  CObjectVector<CPluginToIcon> Plugins;
+};
+
+class CExtDatabase
+{
+  int FindExt(const UString &ext);
+public:
+  CObjectVector<CExtPlugins> Exts;
+  CObjectVector<CPluginInfo> Plugins;
+  
+  void Read();
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/FoldersPage.cpp b/CPP/7zip/UI/FileManager/FoldersPage.cpp
new file mode 100644
index 0000000..d019bab
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FoldersPage.cpp
@@ -0,0 +1,166 @@
+// FoldersPage.cpp
+
+#include "StdAfx.h"
+
+#include "FoldersPageRes.h"
+#include "FoldersPage.h"
+
+#include "../FileManager/BrowseDialog.h"
+#include "../FileManager/HelpUtils.h"
+#include "../FileManager/LangUtils.h"
+
+using namespace NWindows;
+
+static const UInt32 kLangIDs[] =
+{
+  IDT_FOLDERS_WORKING_FOLDER,
+  IDR_FOLDERS_WORK_SYSTEM,
+  IDR_FOLDERS_WORK_CURRENT,
+  IDR_FOLDERS_WORK_SPECIFIED,
+  IDX_FOLDERS_WORK_FOR_REMOVABLE
+};
+
+static const int kWorkModeButtons[] =
+{
+  IDR_FOLDERS_WORK_SYSTEM,
+  IDR_FOLDERS_WORK_CURRENT,
+  IDR_FOLDERS_WORK_SPECIFIED
+};
+
+#define kFoldersTopic "fm/options.htm#folders"
+
+static const unsigned kNumWorkModeButtons = ARRAY_SIZE(kWorkModeButtons);
+ 
+bool CFoldersPage::OnInit()
+{
+  _initMode = true;
+  _needSave = false;
+
+  LangSetDlgItems(*this, kLangIDs, ARRAY_SIZE(kLangIDs));
+  m_WorkDirInfo.Load();
+
+  CheckButton(IDX_FOLDERS_WORK_FOR_REMOVABLE, m_WorkDirInfo.ForRemovableOnly);
+  
+  CheckRadioButton(kWorkModeButtons[0], kWorkModeButtons[kNumWorkModeButtons - 1],
+      kWorkModeButtons[m_WorkDirInfo.Mode]);
+
+  m_WorkPath.Init(*this, IDE_FOLDERS_WORK_PATH);
+
+  m_WorkPath.SetText(fs2us(m_WorkDirInfo.Path));
+
+  MyEnableControls();
+  
+  _initMode = false;
+  return CPropertyPage::OnInit();
+}
+
+int CFoldersPage::GetWorkMode() const
+{
+  for (unsigned i = 0; i < kNumWorkModeButtons; i++)
+    if (IsButtonCheckedBool(kWorkModeButtons[i]))
+      return i;
+  throw 0;
+}
+
+void CFoldersPage::MyEnableControls()
+{
+  bool enablePath = (GetWorkMode() == NWorkDir::NMode::kSpecified);
+  m_WorkPath.Enable(enablePath);
+  EnableItem(IDB_FOLDERS_WORK_PATH, enablePath);
+}
+
+void CFoldersPage::GetWorkDir(NWorkDir::CInfo &workDirInfo)
+{
+  UString s;
+  m_WorkPath.GetText(s);
+  workDirInfo.Path = us2fs(s);
+  workDirInfo.ForRemovableOnly = IsButtonCheckedBool(IDX_FOLDERS_WORK_FOR_REMOVABLE);
+  workDirInfo.Mode = NWorkDir::NMode::EEnum(GetWorkMode());
+}
+
+/*
+bool CFoldersPage::WasChanged()
+{
+  NWorkDir::CInfo workDirInfo;
+  GetWorkDir(workDirInfo);
+  return (workDirInfo.Mode != m_WorkDirInfo.Mode ||
+      workDirInfo.ForRemovableOnly != m_WorkDirInfo.ForRemovableOnly ||
+      workDirInfo.Path.Compare(m_WorkDirInfo.Path) != 0);
+}
+*/
+
+void CFoldersPage::ModifiedEvent()
+{
+  if (!_initMode)
+  {
+    _needSave = true;
+    Changed();
+  }
+  /*
+  if (WasChanged())
+    Changed();
+  else
+    UnChanged();
+  */
+}
+
+bool CFoldersPage::OnButtonClicked(int buttonID, HWND buttonHWND)
+{
+  for (unsigned i = 0; i < kNumWorkModeButtons; i++)
+    if (buttonID == kWorkModeButtons[i])
+    {
+      MyEnableControls();
+      ModifiedEvent();
+      return true;
+    }
+  
+  switch (buttonID)
+  {
+    case IDB_FOLDERS_WORK_PATH:
+      OnFoldersWorkButtonPath();
+      return true;
+    case IDX_FOLDERS_WORK_FOR_REMOVABLE:
+      break;
+    default:
+      return CPropertyPage::OnButtonClicked(buttonID, buttonHWND);
+  }
+  
+  ModifiedEvent();
+  return true;
+}
+
+bool CFoldersPage::OnCommand(int code, int itemID, LPARAM lParam)
+{
+  if (code == EN_CHANGE && itemID == IDE_FOLDERS_WORK_PATH)
+  {
+    ModifiedEvent();
+    return true;
+  }
+  return CPropertyPage::OnCommand(code, itemID, lParam);
+}
+
+void CFoldersPage::OnFoldersWorkButtonPath()
+{
+  UString currentPath;
+  m_WorkPath.GetText(currentPath);
+  UString title = LangString(IDS_FOLDERS_SET_WORK_PATH_TITLE);
+  UString resultPath;
+  if (MyBrowseForFolder(*this, title, currentPath, resultPath))
+    m_WorkPath.SetText(resultPath);
+}
+
+LONG CFoldersPage::OnApply()
+{
+  if (_needSave)
+  {
+    GetWorkDir(m_WorkDirInfo);
+    m_WorkDirInfo.Save();
+    _needSave = false;
+  }
+  return PSNRET_NOERROR;
+}
+
+void CFoldersPage::OnNotifyHelp()
+{
+  ShowHelpWindow(kFoldersTopic);
+}
diff --git a/CPP/7zip/UI/FileManager/FoldersPage.h b/CPP/7zip/UI/FileManager/FoldersPage.h
new file mode 100644
index 0000000..71c7bfc
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FoldersPage.h
@@ -0,0 +1,32 @@
+// FoldersPage.h
+ 
+#ifndef __FOLDERS_PAGE_H
+#define __FOLDERS_PAGE_H
+
+#include "../../../Windows/Control/PropertyPage.h"
+
+#include "../Common/ZipRegistry.h"
+
+class CFoldersPage : public NWindows::NControl::CPropertyPage
+{
+  NWorkDir::CInfo m_WorkDirInfo;
+  NWindows::NControl::CDialogChildControl m_WorkPath;
+
+  bool _needSave;
+  bool _initMode;
+
+  void MyEnableControls();
+  void ModifiedEvent();
+  
+  void OnFoldersWorkButtonPath();
+  int GetWorkMode() const;
+  void GetWorkDir(NWorkDir::CInfo &workDirInfo);
+  // bool WasChanged();
+  virtual bool OnInit();
+  virtual bool OnCommand(int code, int itemID, LPARAM lParam);
+  virtual void OnNotifyHelp();
+  virtual LONG OnApply();
+  virtual bool OnButtonClicked(int buttonID, HWND buttonHWND);
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/FoldersPage.rc b/CPP/7zip/UI/FileManager/FoldersPage.rc
new file mode 100644
index 0000000..cb345ea
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FoldersPage.rc
@@ -0,0 +1,23 @@
+#include "FoldersPageRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 240
+#define yc 100
+
+IDD_FOLDERS  MY_PAGE
+#include "FoldersPage2.rc"
+
+#ifdef UNDER_CE
+
+#undef xc
+#define xc SMALL_PAGE_SIZE_X
+
+IDD_FOLDERS_2  MY_PAGE
+#include "FoldersPage2.rc"
+
+#endif
+
+STRINGTABLE
+BEGIN
+  IDS_FOLDERS_SET_WORK_PATH_TITLE  "Specify a location for temporary archive files."
+END
diff --git a/CPP/7zip/UI/FileManager/FoldersPage2.rc b/CPP/7zip/UI/FileManager/FoldersPage2.rc
new file mode 100644
index 0000000..9b9276e
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FoldersPage2.rc
@@ -0,0 +1,16 @@
+CAPTION "Folders"
+BEGIN
+  // GROUPBOX   "&Working folder", IDT_FOLDERS_WORKING_FOLDER, m, m, xc, 98
+
+  LTEXT      "&Working folder", IDT_FOLDERS_WORKING_FOLDER, m, m, xc, 8
+  CONTROL    "&System temp folder", IDR_FOLDERS_WORK_SYSTEM,    "Button", BS_AUTORADIOBUTTON | WS_GROUP,
+             m, 20, xc, 10
+  CONTROL    "&Current",            IDR_FOLDERS_WORK_CURRENT,   "Button", BS_AUTORADIOBUTTON,
+             m, 34, xc, 10
+  CONTROL    "Specified:",          IDR_FOLDERS_WORK_SPECIFIED, "Button", BS_AUTORADIOBUTTON,
+             m, 48, xc, 10
+  EDITTEXT   IDE_FOLDERS_WORK_PATH, m + m, 62, xc - m - m - bxsDots, 14, ES_AUTOHSCROLL
+  PUSHBUTTON "...", IDB_FOLDERS_WORK_PATH, xs - m - bxsDots, 61, bxsDots, bys
+  CONTROL    "Use for removable drives only", IDX_FOLDERS_WORK_FOR_REMOVABLE, MY_CHECKBOX,
+             m, 86, xc, 10
+END
diff --git a/CPP/7zip/UI/FileManager/FoldersPageRes.h b/CPP/7zip/UI/FileManager/FoldersPageRes.h
new file mode 100644
index 0000000..ba9ab73
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FoldersPageRes.h
@@ -0,0 +1,12 @@
+#define IDD_FOLDERS     2400
+#define IDD_FOLDERS_2  12400
+
+#define IDT_FOLDERS_WORKING_FOLDER      2401
+#define IDR_FOLDERS_WORK_SYSTEM         2402
+#define IDR_FOLDERS_WORK_CURRENT        2403
+#define IDR_FOLDERS_WORK_SPECIFIED      2404
+#define IDX_FOLDERS_WORK_FOR_REMOVABLE  2405
+#define IDS_FOLDERS_SET_WORK_PATH_TITLE 2406
+
+#define IDE_FOLDERS_WORK_PATH  100
+#define IDB_FOLDERS_WORK_PATH  101
diff --git a/CPP/7zip/UI/FileManager/FormatUtils.cpp b/CPP/7zip/UI/FileManager/FormatUtils.cpp
new file mode 100644
index 0000000..2143c3f
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FormatUtils.cpp
@@ -0,0 +1,28 @@
+// FormatUtils.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+
+#include "FormatUtils.h"
+
+#include "LangUtils.h"
+
+UString NumberToString(UInt64 number)
+{
+  wchar_t numberString[32];
+  ConvertUInt64ToString(number, numberString);
+  return numberString;
+}
+
+UString MyFormatNew(const UString &format, const UString &argument)
+{
+  UString result = format;
+  result.Replace(L"{0}", argument);
+  return result;
+}
+
+UString MyFormatNew(UINT resourceID, const UString &argument)
+{
+  return MyFormatNew(LangString(resourceID), argument);
+}
diff --git a/CPP/7zip/UI/FileManager/FormatUtils.h b/CPP/7zip/UI/FileManager/FormatUtils.h
new file mode 100644
index 0000000..993e803
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FormatUtils.h
@@ -0,0 +1,14 @@
+// FormatUtils.h
+
+#ifndef __FORMAT_UTILS_H
+#define __FORMAT_UTILS_H
+
+#include "../../../Common/MyTypes.h"
+#include "../../../Common/MyString.h"
+
+UString NumberToString(UInt64 number);
+
+UString MyFormatNew(const UString &format, const UString &argument);
+UString MyFormatNew(UINT resourceID, const UString &argument);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/HelpUtils.cpp b/CPP/7zip/UI/FileManager/HelpUtils.cpp
new file mode 100644
index 0000000..2db9501
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/HelpUtils.cpp
@@ -0,0 +1,32 @@
+// HelpUtils.cpp
+
+#include "StdAfx.h"
+
+#include "HelpUtils.h"
+
+#if defined(UNDER_CE) || !defined(_WIN32) /* || !defined(_MSC_VER) */
+
+void ShowHelpWindow(LPCSTR)
+{
+}
+
+#else
+
+#include <HtmlHelp.h>
+
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/DLL.h"
+
+#define kHelpFileName "7-zip.chm::/"
+
+void ShowHelpWindow(LPCSTR topicFile)
+{
+  FString path = NWindows::NDLL::GetModuleDirPrefix();
+  path += kHelpFileName;
+  path += topicFile;
+  // HWND hwnd = NULL;
+  HtmlHelp(NULL, GetSystemString(fs2us(path)), HH_DISPLAY_TOPIC, 0);
+}
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/HelpUtils.h b/CPP/7zip/UI/FileManager/HelpUtils.h
new file mode 100644
index 0000000..90c5f7d
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/HelpUtils.h
@@ -0,0 +1,10 @@
+// HelpUtils.h
+
+#ifndef __HELP_UTILS_H
+#define __HELP_UTILS_H
+
+#include "../../../Common/MyString.h"
+
+void ShowHelpWindow(LPCSTR topicFile);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/IFolder.h b/CPP/7zip/UI/FileManager/IFolder.h
new file mode 100644
index 0000000..c5cff06
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/IFolder.h
@@ -0,0 +1,218 @@
+// IFolder.h
+
+#ifndef __IFOLDER_H
+#define __IFOLDER_H
+
+#include "../../IProgress.h"
+#include "../../IStream.h"
+
+#define FOLDER_INTERFACE_SUB(i, b, x) DECL_INTERFACE_SUB(i, b, 8, x)
+#define FOLDER_INTERFACE(i, x) FOLDER_INTERFACE_SUB(i, IUnknown, x)
+
+namespace NPlugin
+{
+  enum
+  {
+    kName = 0,
+    kType,
+    kClassID,
+    kOptionsClassID
+  };
+}
+
+#define INTERFACE_FolderFolder(x) \
+  STDMETHOD(LoadItems)() x; \
+  STDMETHOD(GetNumberOfItems)(UInt32 *numItems) x; \
+  STDMETHOD(GetProperty)(UInt32 itemIndex, PROPID propID, PROPVARIANT *value) x; \
+  STDMETHOD(BindToFolder)(UInt32 index, IFolderFolder **resultFolder) x; \
+  STDMETHOD(BindToFolder)(const wchar_t *name, IFolderFolder **resultFolder) x; \
+  STDMETHOD(BindToParentFolder)(IFolderFolder **resultFolder) x; \
+  STDMETHOD(GetNumberOfProperties)(UInt32 *numProperties) x; \
+  STDMETHOD(GetPropertyInfo)(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType) x; \
+  STDMETHOD(GetFolderProperty)(PROPID propID, PROPVARIANT *value) x; \
+
+FOLDER_INTERFACE(IFolderFolder, 0x00)
+{
+  INTERFACE_FolderFolder(PURE)
+};
+
+/*
+  IFolderAltStreams::
+    BindToAltStreams((UInt32)(Int32)-1, ... ) means alt streams of that folder
+*/
+
+#define INTERFACE_FolderAltStreams(x) \
+  STDMETHOD(BindToAltStreams)(UInt32 index, IFolderFolder **resultFolder) x; \
+  STDMETHOD(BindToAltStreams)(const wchar_t *name, IFolderFolder **resultFolder) x; \
+  STDMETHOD(AreAltStreamsSupported)(UInt32 index, Int32 *isSupported) x; \
+
+FOLDER_INTERFACE(IFolderAltStreams, 0x17)
+{
+  INTERFACE_FolderAltStreams(PURE)
+};
+
+FOLDER_INTERFACE(IFolderWasChanged, 0x04)
+{
+  STDMETHOD(WasChanged)(Int32 *wasChanged) PURE;
+};
+
+FOLDER_INTERFACE_SUB(IFolderOperationsExtractCallback, IProgress, 0x0B)
+{
+  // STDMETHOD(SetTotalFiles)(UInt64 total) PURE;
+  // STDMETHOD(SetCompletedFiles)(const UInt64 *completedValue) PURE;
+  STDMETHOD(AskWrite)(
+      const wchar_t *srcPath,
+      Int32 srcIsFolder,
+      const FILETIME *srcTime,
+      const UInt64 *srcSize,
+      const wchar_t *destPathRequest,
+      BSTR *destPathResult,
+      Int32 *writeAnswer) PURE;
+  STDMETHOD(ShowMessage)(const wchar_t *message) PURE;
+  STDMETHOD(SetCurrentFilePath)(const wchar_t *filePath) PURE;
+  STDMETHOD(SetNumFiles)(UInt64 numFiles) PURE;
+};
+
+#define INTERFACE_FolderOperations(x) \
+  STDMETHOD(CreateFolder)(const wchar_t *name, IProgress *progress) x; \
+  STDMETHOD(CreateFile)(const wchar_t *name, IProgress *progress) x; \
+  STDMETHOD(Rename)(UInt32 index, const wchar_t *newName, IProgress *progress) x; \
+  STDMETHOD(Delete)(const UInt32 *indices, UInt32 numItems, IProgress *progress) x; \
+  STDMETHOD(CopyTo)(Int32 moveMode, const UInt32 *indices, UInt32 numItems, \
+      Int32 includeAltStreams, Int32 replaceAltStreamCharsMode, \
+      const wchar_t *path, IFolderOperationsExtractCallback *callback) x; \
+  STDMETHOD(CopyFrom)(Int32 moveMode, const wchar_t *fromFolderPath, \
+      const wchar_t * const *itemsPaths, UInt32 numItems, IProgress *progress) x; \
+  STDMETHOD(SetProperty)(UInt32 index, PROPID propID, const PROPVARIANT *value, IProgress *progress) x; \
+  STDMETHOD(CopyFromFile)(UInt32 index, const wchar_t *fullFilePath, IProgress *progress) x; \
+
+FOLDER_INTERFACE(IFolderOperations, 0x13)
+{
+  INTERFACE_FolderOperations(PURE)
+};
+
+/*
+FOLDER_INTERFACE2(IFolderOperationsDeleteToRecycleBin, 0x06, 0x03)
+{
+  STDMETHOD(DeleteToRecycleBin)(const UInt32 *indices, UInt32 numItems, IProgress *progress) PURE;
+};
+*/
+
+FOLDER_INTERFACE(IFolderGetSystemIconIndex, 0x07)
+{
+  STDMETHOD(GetSystemIconIndex)(UInt32 index, Int32 *iconIndex) PURE;
+};
+
+FOLDER_INTERFACE(IFolderGetItemFullSize, 0x08)
+{
+  STDMETHOD(GetItemFullSize)(UInt32 index, PROPVARIANT *value, IProgress *progress) PURE;
+};
+
+FOLDER_INTERFACE(IFolderCalcItemFullSize, 0x14)
+{
+  STDMETHOD(CalcItemFullSize)(UInt32 index, IProgress *progress) PURE;
+};
+
+FOLDER_INTERFACE(IFolderClone, 0x09)
+{
+  STDMETHOD(Clone)(IFolderFolder **resultFolder) PURE;
+};
+
+FOLDER_INTERFACE(IFolderSetFlatMode, 0x0A)
+{
+  STDMETHOD(SetFlatMode)(Int32 flatMode) PURE;
+};
+
+/*
+FOLDER_INTERFACE(IFolderSetShowNtfsStreamsMode, 0xFA)
+{
+  STDMETHOD(SetShowNtfsStreamsMode)(Int32 showStreamsMode) PURE;
+};
+*/
+
+#define INTERFACE_FolderProperties(x) \
+  STDMETHOD(GetNumberOfFolderProperties)(UInt32 *numProperties) x; \
+  STDMETHOD(GetFolderPropertyInfo)(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType) x; \
+
+FOLDER_INTERFACE(IFolderProperties, 0x0E)
+{
+  INTERFACE_FolderProperties(PURE)
+};
+
+#define INTERFACE_IFolderArcProps(x) \
+  STDMETHOD(GetArcNumLevels)(UInt32 *numLevels) x; \
+  STDMETHOD(GetArcProp)(UInt32 level, PROPID propID, PROPVARIANT *value) x; \
+  STDMETHOD(GetArcNumProps)(UInt32 level, UInt32 *numProps) x; \
+  STDMETHOD(GetArcPropInfo)(UInt32 level, UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType) x; \
+  STDMETHOD(GetArcProp2)(UInt32 level, PROPID propID, PROPVARIANT *value) x; \
+  STDMETHOD(GetArcNumProps2)(UInt32 level, UInt32 *numProps) x; \
+  STDMETHOD(GetArcPropInfo2)(UInt32 level, UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType) x; \
+
+FOLDER_INTERFACE(IFolderArcProps, 0x10)
+{
+  INTERFACE_IFolderArcProps(PURE)
+};
+
+FOLDER_INTERFACE(IGetFolderArcProps, 0x11)
+{
+  STDMETHOD(GetFolderArcProps)(IFolderArcProps **object) PURE;
+};
+
+FOLDER_INTERFACE(IFolderCompare, 0x15)
+{
+  STDMETHOD_(Int32, CompareItems)(UInt32 index1, UInt32 index2, PROPID propID, Int32 propIsRaw) PURE;
+};
+
+#define INTERFACE_IFolderGetItemName(x) \
+  STDMETHOD(GetItemName)(UInt32 index, const wchar_t **name, unsigned *len) x; \
+  STDMETHOD(GetItemPrefix)(UInt32 index, const wchar_t **name, unsigned *len) x; \
+  STDMETHOD_(UInt64, GetItemSize)(UInt32 index) x; \
+
+FOLDER_INTERFACE(IFolderGetItemName, 0x16)
+{
+  INTERFACE_IFolderGetItemName(PURE)
+};
+
+#define FOLDER_MANAGER_INTERFACE(i, x)  DECL_INTERFACE(i, 9, x)
+
+#define INTERFACE_IFolderManager(x) \
+  STDMETHOD(OpenFolderFile)(IInStream *inStream, const wchar_t *filePath, const wchar_t *arcFormat, IFolderFolder **resultFolder, IProgress *progress) x; \
+  STDMETHOD(GetExtensions)(BSTR *extensions) x; \
+  STDMETHOD(GetIconPath)(const wchar_t *ext, BSTR *iconPath, Int32 *iconIndex) x; \
+  
+  // STDMETHOD(GetTypes)(BSTR *types) PURE;
+  // STDMETHOD(CreateFolderFile)(const wchar_t *type, const wchar_t *filePath, IProgress *progress) PURE;
+            
+FOLDER_MANAGER_INTERFACE(IFolderManager, 0x05)
+{
+  INTERFACE_IFolderManager(PURE);
+};
+
+/*
+#define IMP_IFolderFolder_GetProp(k) \
+  (UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType) \
+    { if (index >= ARRAY_SIZE(k)) return E_INVALIDARG; \
+    const CMy_STATPROPSTG_2 &srcItem = k[index]; \
+    *propID = srcItem.propid; *varType = srcItem.vt; *name = 0; return S_OK; } \
+
+#define IMP_IFolderFolder_Props(c) \
+  STDMETHODIMP c::GetNumberOfProperties(UInt32 *numProperties) \
+    { *numProperties = ARRAY_SIZE(kProps); return S_OK; } \
+  STDMETHODIMP c::GetPropertyInfo IMP_IFolderFolder_GetProp(kProps)
+*/
+
+#define IMP_IFolderFolder_GetProp(k) \
+  (UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType) \
+    { if (index >= ARRAY_SIZE(k)) return E_INVALIDARG; \
+    *propID = k[index]; *varType = k7z_PROPID_To_VARTYPE[(unsigned)*propID]; *name = 0; return S_OK; } \
+
+#define IMP_IFolderFolder_Props(c) \
+  STDMETHODIMP c::GetNumberOfProperties(UInt32 *numProperties) \
+    { *numProperties = ARRAY_SIZE(kProps); return S_OK; } \
+  STDMETHODIMP c::GetPropertyInfo IMP_IFolderFolder_GetProp(kProps)
+
+
+int CompareFileNames_ForFolderList(const wchar_t *s1, const wchar_t *s2);
+// int CompareFileNames_ForFolderList(const FChar *s1, const FChar *s2);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/Info.bmp b/CPP/7zip/UI/FileManager/Info.bmp
new file mode 100644
index 0000000..d769a66
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Info.bmp
diff --git a/CPP/7zip/UI/FileManager/Info2.bmp b/CPP/7zip/UI/FileManager/Info2.bmp
new file mode 100644
index 0000000..af724d2
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Info2.bmp
diff --git a/CPP/7zip/UI/FileManager/LangPage.cpp b/CPP/7zip/UI/FileManager/LangPage.cpp
new file mode 100644
index 0000000..47e7894
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/LangPage.cpp
@@ -0,0 +1,120 @@
+// LangPage.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/Lang.h"
+
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/ResourceString.h"
+
+#include "HelpUtils.h"
+#include "LangPage.h"
+#include "LangPageRes.h"
+#include "LangUtils.h"
+#include "RegistryUtils.h"
+
+using namespace NWindows;
+
+static const UInt32 kLangIDs[] =
+{
+  IDT_LANG_LANG
+};
+
+#define kLangTopic "fm/options.htm#language"
+
+static void NativeLangString(UString &dest, const wchar_t *s)
+{
+  dest += " (";
+  dest += s;
+  dest += ')';
+}
+
+bool LangOpen(CLang &lang, CFSTR fileName);
+
+bool CLangPage::OnInit()
+{
+  LangSetDlgItems(*this, kLangIDs, ARRAY_SIZE(kLangIDs));
+
+  _langCombo.Attach(GetItem(IDC_LANG_LANG));
+
+  UString temp = MyLoadString(IDS_LANG_ENGLISH);
+  NativeLangString(temp, MyLoadString(IDS_LANG_NATIVE));
+  int index = (int)_langCombo.AddString(temp);
+  _langCombo.SetItemData(index, _paths.Size());
+  _paths.Add(L"-");
+  _langCombo.SetCurSel(0);
+
+  const FString dirPrefix = GetLangDirPrefix();
+  NFile::NFind::CEnumerator enumerator;
+  enumerator.SetDirPrefix(dirPrefix);
+  NFile::NFind::CFileInfo fi;
+  CLang lang;
+  UString error;
+  
+  while (enumerator.Next(fi))
+  {
+    if (fi.IsDir())
+      continue;
+    const unsigned kExtSize = 4;
+    if (fi.Name.Len() < kExtSize)
+      continue;
+    const unsigned pos = fi.Name.Len() - kExtSize;
+    if (!StringsAreEqualNoCase_Ascii(fi.Name.Ptr(pos), ".txt"))
+    {
+      // if (!StringsAreEqualNoCase_Ascii(fi.Name.Ptr(pos), ".ttt"))
+      continue;
+    }
+
+    if (!LangOpen(lang, dirPrefix + fi.Name))
+    {
+      error.Add_Space_if_NotEmpty();
+      error += fs2us(fi.Name);
+      continue;
+    }
+    
+    const UString shortName = fs2us(fi.Name.Left(pos));
+    UString s = shortName;
+    const wchar_t *eng = lang.Get(IDS_LANG_ENGLISH);
+    if (eng)
+      s = eng;
+    const wchar_t *native = lang.Get(IDS_LANG_NATIVE);
+    if (native)
+      NativeLangString(s, native);
+    index = (int)_langCombo.AddString(s);
+    _langCombo.SetItemData(index, _paths.Size());
+    _paths.Add(shortName);
+    if (g_LangID.IsEqualTo_NoCase(shortName))
+      _langCombo.SetCurSel(index);
+  }
+  
+  if (!error.IsEmpty())
+    MessageBoxW(0, error, L"Error in Lang file", MB_ICONERROR);
+  return CPropertyPage::OnInit();
+}
+
+LONG CLangPage::OnApply()
+{
+  int pathIndex = (int)_langCombo.GetItemData_of_CurSel();
+  if (_needSave)
+    SaveRegLang(_paths[pathIndex]);
+  _needSave = false;
+  ReloadLang();
+  LangWasChanged = true;
+  return PSNRET_NOERROR;
+}
+
+void CLangPage::OnNotifyHelp()
+{
+  ShowHelpWindow(kLangTopic);
+}
+
+bool CLangPage::OnCommand(int code, int itemID, LPARAM param)
+{
+  if (code == CBN_SELCHANGE && itemID == IDC_LANG_LANG)
+  {
+    _needSave = true;
+    Changed();
+    return true;
+  }
+  return CPropertyPage::OnCommand(code, itemID, param);
+}
diff --git a/CPP/7zip/UI/FileManager/LangPage.h b/CPP/7zip/UI/FileManager/LangPage.h
new file mode 100644
index 0000000..b806257
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/LangPage.h
@@ -0,0 +1,25 @@
+// LangPage.h
+ 
+#ifndef __LANG_PAGE_H
+#define __LANG_PAGE_H
+
+#include "../../../Windows/Control/PropertyPage.h"
+#include "../../../Windows/Control/ComboBox.h"
+
+class CLangPage: public NWindows::NControl::CPropertyPage
+{
+  NWindows::NControl::CComboBox _langCombo;
+  UStringVector _paths;
+
+  bool _needSave;
+public:
+  bool LangWasChanged;
+  
+  CLangPage(): _needSave(false), LangWasChanged(false) {}
+  virtual bool OnInit();
+  virtual void OnNotifyHelp();
+  virtual bool OnCommand(int code, int itemID, LPARAM param);
+  virtual LONG OnApply();
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/LangPage.rc b/CPP/7zip/UI/FileManager/LangPage.rc
new file mode 100644
index 0000000..164e2d3
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/LangPage.rc
@@ -0,0 +1,37 @@
+#include "LangPageRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 160
+#define yc 100
+
+IDD_LANG  DIALOG  0, 0, xs, ys  MY_PAGE_STYLE  MY_FONT
+CAPTION "Language"
+{
+  LTEXT     "Language:", IDT_LANG_LANG, m, m, xc, 8
+  COMBOBOX  IDC_LANG_LANG, m, 20, xc, yc - 20, MY_COMBO_SORTED
+}
+
+
+#ifdef UNDER_CE
+
+#undef m
+#undef xc
+
+#define m 4
+#define xc (SMALL_PAGE_SIZE_X + 8)
+
+IDD_LANG_2  MY_PAGE
+CAPTION "Language"
+{
+  LTEXT     "Language:", IDT_LANG_LANG, m, m, xc, 8
+  COMBOBOX  IDC_LANG_LANG, m, 20, xc, yc - 20, MY_COMBO_SORTED
+}
+
+#endif
+
+
+STRINGTABLE
+BEGIN
+  IDS_LANG_ENGLISH  "English"
+  IDS_LANG_NATIVE   "English"
+END
diff --git a/CPP/7zip/UI/FileManager/LangPageRes.h b/CPP/7zip/UI/FileManager/LangPageRes.h
new file mode 100644
index 0000000..d7a39d7
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/LangPageRes.h
@@ -0,0 +1,8 @@
+#define IDD_LANG     2101
+#define IDD_LANG_2  12101
+
+#define IDS_LANG_ENGLISH   1
+#define IDS_LANG_NATIVE    2
+
+#define IDT_LANG_LANG   2102
+#define IDC_LANG_LANG    100
diff --git a/CPP/7zip/UI/FileManager/LangUtils.cpp b/CPP/7zip/UI/FileManager/LangUtils.cpp
new file mode 100644
index 0000000..83d5aa7
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/LangUtils.cpp
@@ -0,0 +1,293 @@
+// LangUtils.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/Lang.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/Synchronization.h"
+#include "../../../Windows/Window.h"
+
+#include "LangUtils.h"
+#include "RegistryUtils.h"
+
+using namespace NWindows;
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+UString g_LangID;
+
+static CLang g_Lang;
+static bool g_Loaded = false;
+static NSynchronization::CCriticalSection g_CriticalSection;
+
+bool LangOpen(CLang &lang, CFSTR fileName);
+bool LangOpen(CLang &lang, CFSTR fileName)
+{
+  return lang.Open(fileName, "7-Zip");
+}
+
+FString GetLangDirPrefix()
+{
+  return NDLL::GetModuleDirPrefix() + FTEXT("Lang") FSTRING_PATH_SEPARATOR;
+}
+
+void LoadLangOneTime()
+{
+  NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
+  if (g_Loaded)
+    return;
+  g_Loaded = true;
+  ReloadLang();
+}
+
+void LangSetDlgItemText(HWND dialog, UInt32 controlID, UInt32 langID)
+{
+  const wchar_t *s = g_Lang.Get(langID);
+  if (s)
+  {
+    CWindow window(GetDlgItem(dialog, controlID));
+    window.SetText(s);
+  }
+}
+
+static const CIDLangPair kLangPairs[] =
+{
+  { IDOK,     401 },
+  { IDCANCEL, 402 },
+  { IDYES,    406 },
+  { IDNO,     407 },
+  { IDCLOSE,  408 },
+  { IDHELP,   409 }
+};
+
+
+void LangSetDlgItems(HWND dialog, const UInt32 *ids, unsigned numItems)
+{
+  unsigned i;
+  for (i = 0; i < ARRAY_SIZE(kLangPairs); i++)
+  {
+    const CIDLangPair &pair = kLangPairs[i];
+    CWindow window(GetDlgItem(dialog, pair.ControlID));
+    if (window)
+    {
+      const wchar_t *s = g_Lang.Get(pair.LangID);
+      if (s)
+        window.SetText(s);
+    }
+  }
+
+  for (i = 0; i < numItems; i++)
+  {
+    UInt32 id = ids[i];
+    LangSetDlgItemText(dialog, id, id);
+  }
+}
+
+void LangSetDlgItems_Colon(HWND dialog, const UInt32 *ids, unsigned numItems)
+{
+  for (unsigned i = 0; i < numItems; i++)
+  {
+    UInt32 id = ids[i];
+    const wchar_t *s = g_Lang.Get(id);
+    if (s)
+    {
+      CWindow window(GetDlgItem(dialog, id));
+      UString s2 = s;
+      s2 += ':';
+      window.SetText(s2);
+    }
+  }
+}
+
+void LangSetWindowText(HWND window, UInt32 langID)
+{
+  const wchar_t *s = g_Lang.Get(langID);
+  if (s)
+    MySetWindowText(window, s);
+}
+
+UString LangString(UInt32 langID)
+{
+  const wchar_t *s = g_Lang.Get(langID);
+  if (s)
+    return s;
+  return MyLoadString(langID);
+}
+
+void AddLangString(UString &s, UInt32 langID)
+{
+  s += LangString(langID);
+}
+
+void LangString(UInt32 langID, UString &dest)
+{
+  const wchar_t *s = g_Lang.Get(langID);
+  if (s)
+  {
+    dest = s;
+    return;
+  }
+  MyLoadString(langID, dest);
+}
+
+void LangString_OnlyFromLangFile(UInt32 langID, UString &dest)
+{
+  dest.Empty();
+  const wchar_t *s = g_Lang.Get(langID);
+  if (s)
+    dest = s;
+}
+
+static const char * const kLangs =
+  "ar.bg.ca.zh.-tw.-cn.cs.da.de.el.en.es.fi.fr.he.hu.is."
+  "it.ja.ko.nl.no.=nb.=nn.pl.pt.-br.rm.ro.ru.sr.=hr.-spl.-spc.sk.sq.sv.th.tr."
+  "ur.id.uk.be.sl.et.lv.lt.tg.fa.vi.hy.az.eu.hsb.mk."
+  "st.ts.tn.ve.xh.zu.af.ka.fo.hi.mt.se.ga.yi.ms.kk."
+  "ky.sw.tk.uz.-latn.-cyrl.tt.bn.pa.-in.gu.or.ta.te.kn.ml.as.mr.sa."
+  "mn.=mn.=mng.bo.cy.kh.lo.my.gl.kok..sd.syr.si..iu.am.tzm."
+  "ks.ne.fy.ps.tl.dv..ff.ha..yo.qu.st.ba.lb.kl."
+  "ig.kr.om.ti.gn..la.so.ii..arn..moh..br.."
+  "ug.mi.oc.co."
+  // "gsw.sah.qut.rw.wo....prs...."
+  // ".gd."
+  ;
+
+static void FindShortNames(UInt32 primeLang, AStringVector &names)
+{
+  UInt32 index = 0;
+  for (const char *p = kLangs; *p != 0;)
+  {
+    const char *p2 = p;
+    for (; *p2 != '.'; p2++);
+    bool isSub = (p[0] == '-' || p[0] == '=');
+    if (!isSub)
+      index++;
+    if (index >= primeLang)
+    {
+      if (index > primeLang)
+        break;
+      AString s;
+      if (isSub)
+      {
+        if (p[0] == '-')
+          s = names[0];
+        else
+          p++;
+      }
+      while (p != p2)
+        s += (char)(Byte)*p++;
+      names.Add(s);
+    }
+    p = p2 + 1;
+  }
+}
+
+/*
+#include "../../../Common/IntToString.h"
+
+static struct CC1Lang
+{
+  CC1Lang()
+  {
+    for (int i = 1; i < 150; i++)
+    {
+      UString s;
+      char ttt[32];
+      ConvertUInt32ToHex(i, ttt);
+      s += ttt;
+      UStringVector names;
+      FindShortNames(i, names);
+
+      FOR_VECTOR (k, names)
+      {
+        s.Add_Space();
+        s += names[k];
+      }
+      OutputDebugStringW(s);
+    }
+  }
+} g_cc1;
+*/
+
+// typedef LANGID (WINAPI *GetUserDefaultUILanguageP)();
+
+static void OpenDefaultLang()
+{
+  LANGID sysLang = GetSystemDefaultLangID(); // "Language for non-Unicode programs" in XP64
+  LANGID userLang = GetUserDefaultLangID(); // "Standards and formats" language in XP64
+
+  if (sysLang != userLang)
+    return;
+  LANGID langID = userLang;
+  
+  /*
+  LANGID sysUILang; // english  in XP64
+  LANGID userUILang; // english  in XP64
+
+  GetUserDefaultUILanguageP fn = (GetUserDefaultUILanguageP)GetProcAddress(
+      GetModuleHandle("kernel32"), "GetUserDefaultUILanguage");
+  if (fn)
+    userUILang = fn();
+  fn = (GetUserDefaultUILanguageP)GetProcAddress(
+      GetModuleHandle("kernel32"), "GetSystemDefaultUILanguage");
+  if (fn)
+    sysUILang = fn();
+  */
+
+  WORD primLang = (WORD)(PRIMARYLANGID(langID));
+  WORD subLang = (WORD)(SUBLANGID(langID));
+  {
+    AStringVector names;
+    FindShortNames(primLang, names);
+    const FString dirPrefix (GetLangDirPrefix());
+    for (unsigned i = 0; i < 2; i++)
+    {
+      unsigned index = (i == 0 ? subLang : 0);
+      if (index < names.Size())
+      {
+        const AString &name = names[index];
+        if (!name.IsEmpty())
+        {
+          FString path (dirPrefix);
+          path += name;
+          path += ".txt";
+          if (LangOpen(g_Lang, path))
+          {
+            g_LangID = name;
+            return;
+          }
+        }
+      }
+    }
+  }
+}
+
+void ReloadLang()
+{
+  g_Lang.Clear();
+  ReadRegLang(g_LangID);
+  #ifndef _UNICODE
+  if (g_IsNT)
+  #endif
+  {
+    if (g_LangID.IsEmpty())
+    {
+      OpenDefaultLang();
+      return;
+    }
+  }
+  if (g_LangID.Len() > 1 || g_LangID[0] != L'-')
+  {
+    FString s = us2fs(g_LangID);
+    if (s.Find(FCHAR_PATH_SEPARATOR) < 0)
+    {
+      if (s.Find(FTEXT('.')) < 0)
+        s += ".txt";
+      s.Insert(0, GetLangDirPrefix());
+    }
+    LangOpen(g_Lang, s);
+  }
+}
diff --git a/CPP/7zip/UI/FileManager/LangUtils.h b/CPP/7zip/UI/FileManager/LangUtils.h
new file mode 100644
index 0000000..d63a443
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/LangUtils.h
@@ -0,0 +1,40 @@
+// LangUtils.h
+
+#ifndef __LANG_UTILS_H
+#define __LANG_UTILS_H
+
+#include "../../../Windows/ResourceString.h"
+
+#ifdef LANG
+
+extern UString g_LangID;
+
+struct CIDLangPair
+{
+  UInt32 ControlID;
+  UInt32 LangID;
+};
+
+void ReloadLang();
+void LoadLangOneTime();
+FString GetLangDirPrefix();
+
+void LangSetDlgItemText(HWND dialog, UInt32 controlID, UInt32 langID);
+void LangSetDlgItems(HWND dialog, const UInt32 *ids, unsigned numItems);
+void LangSetDlgItems_Colon(HWND dialog, const UInt32 *ids, unsigned numItems);
+void LangSetWindowText(HWND window, UInt32 langID);
+
+UString LangString(UInt32 langID);
+void AddLangString(UString &s, UInt32 langID);
+void LangString(UInt32 langID, UString &dest);
+void LangString_OnlyFromLangFile(UInt32 langID, UString &dest);
+ 
+#else
+
+inline UString LangString(UInt32 langID) { return NWindows::MyLoadString(langID); }
+inline void LangString(UInt32 langID, UString &dest) { NWindows::MyLoadString(langID, dest); }
+inline void AddLangString(UString &s, UInt32 langID) { s += NWindows::MyLoadString(langID); }
+
+#endif
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/LinkDialog.cpp b/CPP/7zip/UI/FileManager/LinkDialog.cpp
new file mode 100644
index 0000000..07f1f06
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/LinkDialog.cpp
@@ -0,0 +1,399 @@
+// LinkDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/FileIO.h"
+#include "../../../Windows/FileName.h"
+
+#ifdef LANG
+#include "LangUtils.h"
+#endif
+
+#include "BrowseDialog.h"
+#include "CopyDialogRes.h"
+#include "LinkDialog.h"
+#include "resourceGui.h"
+
+#include "App.h"
+
+#include "resource.h"
+
+extern bool g_SymLink_Supported;
+
+using namespace NWindows;
+using namespace NFile;
+
+#ifdef LANG
+static const UInt32 kLangIDs[] =
+{
+  IDB_LINK_LINK,
+  IDT_LINK_PATH_FROM,
+  IDT_LINK_PATH_TO,
+  IDG_LINK_TYPE,
+  IDR_LINK_TYPE_HARD,
+  IDR_LINK_TYPE_SYM_FILE,
+  IDR_LINK_TYPE_SYM_DIR,
+  IDR_LINK_TYPE_JUNCTION,
+  IDR_LINK_TYPE_WSL
+};
+#endif
+
+
+static bool GetSymLink(CFSTR path, CReparseAttr &attr, UString &errorMessage)
+{
+  CByteBuffer buf;
+  if (!NIO::GetReparseData(path, buf, NULL))
+    return false;
+  
+  if (!attr.Parse(buf, buf.Size()))
+  {
+    SetLastError(attr.ErrorCode);
+    return false;
+  }
+
+  CByteBuffer data2;
+  if (!FillLinkData(data2, attr.GetPath(),
+      !attr.IsMountPoint(), attr.IsSymLink_WSL()))
+  {
+    errorMessage = "Cannot reproduce reparse point";
+    return false;
+  }
+    
+  if (data2.Size() != buf.Size() ||
+      memcmp(data2, buf, buf.Size()) != 0)
+  {
+    errorMessage = "mismatch for reproduced reparse point";
+    return false;
+  }
+
+  return true;
+}
+
+
+static const int k_LinkType_Buttons[] =
+{
+  IDR_LINK_TYPE_HARD,
+  IDR_LINK_TYPE_SYM_FILE,
+  IDR_LINK_TYPE_SYM_DIR,
+  IDR_LINK_TYPE_JUNCTION,
+  IDR_LINK_TYPE_WSL
+};
+
+void CLinkDialog::Set_LinkType_Radio(int idb)
+{
+  CheckRadioButton(k_LinkType_Buttons[0], k_LinkType_Buttons[ARRAY_SIZE(k_LinkType_Buttons) - 1], idb);
+}
+
+bool CLinkDialog::OnInit()
+{
+  #ifdef LANG
+  LangSetWindowText(*this, IDD_LINK);
+  LangSetDlgItems(*this, kLangIDs, ARRAY_SIZE(kLangIDs));
+  #endif
+  
+  _pathFromCombo.Attach(GetItem(IDC_LINK_PATH_FROM));
+  _pathToCombo.Attach(GetItem(IDC_LINK_PATH_TO));
+  
+  if (!FilePath.IsEmpty())
+  {
+    NFind::CFileInfo fi;
+    int linkType = 0;
+    if (!fi.Find(us2fs(FilePath)))
+      linkType = IDR_LINK_TYPE_SYM_FILE;
+    else
+    {
+      if (fi.HasReparsePoint())
+      {
+        CReparseAttr attr;
+        UString error;
+        bool res = GetSymLink(us2fs(FilePath), attr, error);
+        if (!res && error.IsEmpty())
+        {
+          DWORD lastError = GetLastError();
+          if (lastError != 0)
+            error = NError::MyFormatMessage(lastError);
+        }
+        
+        UString s = attr.GetPath();
+        if (!attr.IsSymLink_WSL())
+        if (!attr.IsOkNamePair())
+        {
+          s += " : ";
+          s += attr.PrintName;
+        }
+
+        if (!res)
+        {
+          s.Insert(0, L"ERROR: ");
+          if (!error.IsEmpty())
+          {
+            s += " : ";
+            s += error;
+          }
+        }
+
+        
+        SetItemText(IDT_LINK_PATH_TO_CUR, s);
+        
+        UString destPath = attr.GetPath();
+        _pathFromCombo.SetText(FilePath);
+        _pathToCombo.SetText(destPath);
+        
+        // if (res)
+        {
+          if (attr.IsMountPoint())
+            linkType = IDR_LINK_TYPE_JUNCTION;
+          else if (attr.IsSymLink_WSL())
+            linkType = IDR_LINK_TYPE_WSL;
+          else if (attr.IsSymLink_Win())
+          {
+            linkType =
+              fi.IsDir() ?
+                IDR_LINK_TYPE_SYM_DIR :
+                IDR_LINK_TYPE_SYM_FILE;
+            // if (attr.IsRelative()) linkType = IDR_LINK_TYPE_SYM_RELATIVE;
+          }
+          
+          if (linkType != 0)
+            Set_LinkType_Radio(linkType);
+        }
+      }
+      else
+      {
+        // no ReparsePoint
+        _pathFromCombo.SetText(AnotherPath);
+        _pathToCombo.SetText(FilePath);
+        if (fi.IsDir())
+          linkType = g_SymLink_Supported ?
+              IDR_LINK_TYPE_SYM_DIR :
+              IDR_LINK_TYPE_JUNCTION;
+        else
+          linkType = IDR_LINK_TYPE_HARD;
+      }
+    }
+    if (linkType != 0)
+      Set_LinkType_Radio(linkType);
+  }
+
+  NormalizeSize();
+  return CModalDialog::OnInit();
+}
+
+bool CLinkDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+  int mx, my;
+  GetMargins(8, mx, my);
+  int bx1, bx2, by;
+  GetItemSizes(IDCANCEL, bx1, by);
+  GetItemSizes(IDB_LINK_LINK, bx2, by);
+  int yPos = ySize - my - by;
+  int xPos = xSize - mx - bx1;
+
+  InvalidateRect(NULL);
+
+  {
+    RECT r, r2;
+    GetClientRectOfItem(IDB_LINK_PATH_FROM, r);
+    GetClientRectOfItem(IDB_LINK_PATH_TO, r2);
+    int bx = RECT_SIZE_X(r);
+    int newButtonXpos = xSize - mx - bx;
+
+    MoveItem(IDB_LINK_PATH_FROM, newButtonXpos, r.top, bx, RECT_SIZE_Y(r));
+    MoveItem(IDB_LINK_PATH_TO, newButtonXpos, r2.top, bx, RECT_SIZE_Y(r2));
+
+    int newComboXsize = newButtonXpos - mx - mx;
+    ChangeSubWindowSizeX(_pathFromCombo, newComboXsize);
+    ChangeSubWindowSizeX(_pathToCombo, newComboXsize);
+  }
+
+  MoveItem(IDCANCEL, xPos, yPos, bx1, by);
+  MoveItem(IDB_LINK_LINK, xPos - mx - bx2, yPos, bx2, by);
+
+  return false;
+}
+
+bool CLinkDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
+{
+  switch (buttonID)
+  {
+    case IDB_LINK_PATH_FROM:
+      OnButton_SetPath(false);
+      return true;
+    case IDB_LINK_PATH_TO:
+      OnButton_SetPath(true);
+      return true;
+    case IDB_LINK_LINK:
+      OnButton_Link();
+      return true;
+  }
+  return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+}
+
+void CLinkDialog::OnButton_SetPath(bool to)
+{
+  UString currentPath;
+  NWindows::NControl::CComboBox &combo = to ?
+    _pathToCombo :
+    _pathFromCombo;
+  combo.GetText(currentPath);
+  // UString title = "Specify a location for output folder";
+  UString title = LangString(IDS_SET_FOLDER);
+
+  UString resultPath;
+  if (!MyBrowseForFolder(*this, title, currentPath, resultPath))
+    return;
+  NName::NormalizeDirPathPrefix(resultPath);
+  combo.SetCurSel(-1);
+  combo.SetText(resultPath);
+}
+
+void CLinkDialog::ShowError(const wchar_t *s)
+{
+  ::MessageBoxW(*this, s, L"7-Zip", MB_ICONERROR);
+}
+
+void CLinkDialog::ShowLastErrorMessage()
+{
+  ShowError(NError::MyFormatMessage(GetLastError()));
+}
+
+void CLinkDialog::OnButton_Link()
+{
+  UString from, to;
+  _pathFromCombo.GetText(from);
+  _pathToCombo.GetText(to);
+
+  if (from.IsEmpty())
+    return;
+  if (!NName::IsAbsolutePath(from))
+    from.Insert(0, CurDirPrefix);
+
+  int idb = -1;
+  for (unsigned i = 0;; i++)
+  {
+    if (i >= ARRAY_SIZE(k_LinkType_Buttons))
+      return;
+    idb = k_LinkType_Buttons[i];
+    if (IsButtonCheckedBool(idb))
+      break;
+  }
+
+  NFind::CFileInfo info1, info2;
+  const bool finded1 = info1.Find(us2fs(from));
+  const bool finded2 = info2.Find(us2fs(to));
+
+  const bool isDirLink = (
+      idb == IDR_LINK_TYPE_SYM_DIR ||
+      idb == IDR_LINK_TYPE_JUNCTION);
+
+  const bool isWSL = (idb == IDR_LINK_TYPE_WSL);
+
+  if (!isWSL)
+  if ((finded1 && info1.IsDir() != isDirLink) ||
+      (finded2 && info2.IsDir() != isDirLink))
+  {
+    ShowError(L"Incorrect link type");
+    return;
+  }
+  
+  if (idb == IDR_LINK_TYPE_HARD)
+  {
+    if (!NDir::MyCreateHardLink(us2fs(from), us2fs(to)))
+    {
+      ShowLastErrorMessage();
+      return;
+    }
+  }
+  else
+  {
+    if (finded1 && !info1.IsDir() && !info1.HasReparsePoint() && info1.Size != 0)
+    {
+      UString s ("WARNING: reparse point will hide the data of existing file");
+      s.Add_LF();
+      s += from;
+      ShowError(s);
+      return;
+    }
+
+    const bool isSymLink = (idb != IDR_LINK_TYPE_JUNCTION);
+    
+    CByteBuffer data;
+    if (!FillLinkData(data, to, isSymLink, isWSL))
+    {
+      ShowError(L"Incorrect link");
+      return;
+    }
+    
+    CReparseAttr attr;
+    if (!attr.Parse(data, data.Size()))
+    {
+      ShowError(L"Internal conversion error");
+      return;
+    }
+
+    bool res;
+    if (to.IsEmpty())
+    {
+      // res = NIO::SetReparseData(us2fs(from), isDirLink, NULL, 0);
+      res = NIO::DeleteReparseData(us2fs(from));
+    }
+    else
+      res = NIO::SetReparseData(us2fs(from), isDirLink, data, (DWORD)data.Size());
+
+    if (!res)
+    {
+      ShowLastErrorMessage();
+      return;
+    }
+  }
+
+  End(IDOK);
+}
+
+void CApp::Link()
+{
+  unsigned srcPanelIndex = GetFocusedPanelIndex();
+  CPanel &srcPanel = Panels[srcPanelIndex];
+  if (!srcPanel.IsFSFolder())
+  {
+    srcPanel.MessageBox_Error_UnsupportOperation();
+    return;
+  }
+  CRecordVector<UInt32> indices;
+  srcPanel.GetOperatedItemIndices(indices);
+  if (indices.IsEmpty())
+    return;
+  if (indices.Size() != 1)
+  {
+    srcPanel.MessageBox_Error_LangID(IDS_SELECT_ONE_FILE);
+    return;
+  }
+  int index = indices[0];
+  const UString itemName = srcPanel.GetItemName(index);
+
+  const UString fsPrefix = srcPanel.GetFsPath();
+  const UString srcPath = fsPrefix + srcPanel.GetItemPrefix(index);
+  UString path = srcPath;
+  {
+    unsigned destPanelIndex = (NumPanels <= 1) ? srcPanelIndex : (1 - srcPanelIndex);
+    CPanel &destPanel = Panels[destPanelIndex];
+    if (NumPanels > 1)
+      if (destPanel.IsFSFolder())
+        path = destPanel.GetFsPath();
+  }
+
+  CLinkDialog dlg;
+  dlg.CurDirPrefix = fsPrefix;
+  dlg.FilePath = srcPath + itemName;
+  dlg.AnotherPath = path;
+
+  if (dlg.Create(srcPanel.GetParent()) != IDOK)
+    return;
+
+  // fix it: we should refresh panel with changed link
+
+  RefreshTitleAlways();
+}
diff --git a/CPP/7zip/UI/FileManager/LinkDialog.h b/CPP/7zip/UI/FileManager/LinkDialog.h
new file mode 100644
index 0000000..56deec9
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/LinkDialog.h
@@ -0,0 +1,34 @@
+// LinkDialog.h
+
+#ifndef __LINK_DIALOG_H
+#define __LINK_DIALOG_H
+
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/ComboBox.h"
+
+#include "LinkDialogRes.h"
+
+class CLinkDialog: public NWindows::NControl::CModalDialog
+{
+  NWindows::NControl::CComboBox _pathFromCombo;
+  NWindows::NControl::CComboBox _pathToCombo;
+  
+  virtual bool OnInit();
+  virtual bool OnSize(WPARAM wParam, int xSize, int ySize);
+  virtual bool OnButtonClicked(int buttonID, HWND buttonHWND);
+  void OnButton_SetPath(bool to);
+  void OnButton_Link();
+
+  void ShowLastErrorMessage();
+  void ShowError(const wchar_t *s);
+  void Set_LinkType_Radio(int idb);
+public:
+  UString CurDirPrefix;
+  UString FilePath;
+  UString AnotherPath;
+  
+  INT_PTR Create(HWND parentWindow = 0)
+    { return CModalDialog::Create(IDD_LINK, parentWindow); }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/LinkDialog.rc b/CPP/7zip/UI/FileManager/LinkDialog.rc
new file mode 100644
index 0000000..a9e220b
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/LinkDialog.rc
@@ -0,0 +1,38 @@
+#include "LinkDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 288
+#define yc 214
+
+#undef xRadioSize 
+#define xRadioSize xc - m - 2
+
+IDD_LINK  DIALOG  0, 0, xs, ys  MY_MODAL_RESIZE_DIALOG_STYLE  MY_FONT
+CAPTION "Link"
+BEGIN
+  LTEXT       "Link from:", IDT_LINK_PATH_FROM, m, m, xc, 8
+  COMBOBOX    IDC_LINK_PATH_FROM, m, 20, xc - bxsDots - m, 64, MY_COMBO_WITH_EDIT
+  PUSHBUTTON  "...", IDB_LINK_PATH_FROM, xs - m - bxsDots, 18, bxsDots, bys, WS_GROUP
+
+  LTEXT       "Link to:", IDT_LINK_PATH_TO, m, 48, xc, 8
+  COMBOBOX    IDC_LINK_PATH_TO, m, 60, xc - bxsDots - m, 64, MY_COMBO_WITH_EDIT
+  PUSHBUTTON  "...", IDB_LINK_PATH_TO, xs - m - bxsDots, 58, bxsDots, bys, WS_GROUP
+
+  LTEXT       "", IDT_LINK_PATH_TO_CUR, m, 78, xc, 8
+
+  GROUPBOX    "Link Type", IDG_LINK_TYPE, m, 104, xc, 90
+
+  CONTROL    "Hard Link", IDR_LINK_TYPE_HARD, "Button", BS_AUTORADIOBUTTON | WS_GROUP,
+             m + m, 120, xRadioSize, 10
+  CONTROL    "File Symbolic Link", IDR_LINK_TYPE_SYM_FILE, "Button", BS_AUTORADIOBUTTON,
+             m + m, 134, xRadioSize, 10
+  CONTROL    "Directory Symbolic Link", IDR_LINK_TYPE_SYM_DIR, "Button", BS_AUTORADIOBUTTON,
+             m + m, 148, xRadioSize, 10
+  CONTROL    "Directory Junction", IDR_LINK_TYPE_JUNCTION, "Button", BS_AUTORADIOBUTTON,
+             m + m, 162, xRadioSize, 10
+  CONTROL    "WSL", IDR_LINK_TYPE_WSL, "Button", BS_AUTORADIOBUTTON,
+             m + m, 176, xRadioSize, 10
+
+  DEFPUSHBUTTON  "Link",   IDB_LINK_LINK, bx2, by, bxs, bys
+  PUSHBUTTON     "Cancel", IDCANCEL,      bx1, by, bxs, bys
+END
diff --git a/CPP/7zip/UI/FileManager/LinkDialogRes.h b/CPP/7zip/UI/FileManager/LinkDialogRes.h
new file mode 100644
index 0000000..3f7b3f2
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/LinkDialogRes.h
@@ -0,0 +1,22 @@
+#define IDD_LINK  7700
+
+#define IDB_LINK_LINK           7701
+
+#define IDT_LINK_PATH_FROM      7702
+#define IDT_LINK_PATH_TO        7703
+
+#define IDG_LINK_TYPE           7710
+#define IDR_LINK_TYPE_HARD      7711
+#define IDR_LINK_TYPE_SYM_FILE  7712
+#define IDR_LINK_TYPE_SYM_DIR   7713
+#define IDR_LINK_TYPE_JUNCTION  7714
+#define IDR_LINK_TYPE_WSL       7715
+
+
+#define IDC_LINK_PATH_FROM    100
+#define IDC_LINK_PATH_TO      101
+
+#define IDT_LINK_PATH_TO_CUR  102
+
+#define IDB_LINK_PATH_FROM    103
+#define IDB_LINK_PATH_TO      104
diff --git a/CPP/7zip/UI/FileManager/ListViewDialog.cpp b/CPP/7zip/UI/FileManager/ListViewDialog.cpp
new file mode 100644
index 0000000..a42e790
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ListViewDialog.cpp
@@ -0,0 +1,321 @@
+// ListViewDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/Clipboard.h"
+
+#include "EditDialog.h"
+#include "ListViewDialog.h"
+#include "RegistryUtils.h"
+
+#ifdef LANG
+#include "LangUtils.h"
+#endif
+
+using namespace NWindows;
+
+static const unsigned kOneStringMaxSize = 1024;
+
+
+static void ListView_GetSelected(NControl::CListView &listView, CUIntVector &vector)
+{
+  vector.Clear();
+  int index = -1;
+  for (;;)
+  {
+    index = listView.GetNextSelectedItem(index);
+    if (index < 0)
+      break;
+    vector.Add(index);
+  }
+}
+
+
+bool CListViewDialog::OnInit()
+{
+  #ifdef LANG
+  LangSetDlgItems(*this, NULL, 0);
+  #endif
+  _listView.Attach(GetItem(IDL_LISTVIEW));
+
+  if (NumColumns > 1)
+  {
+    LONG_PTR style = _listView.GetStyle();
+    style &= ~(LONG_PTR)LVS_NOCOLUMNHEADER;
+    _listView.SetStyle(style);
+  }
+
+  CFmSettings st;
+  st.Load();
+
+  DWORD exStyle = 0;
+  
+  if (st.SingleClick)
+    exStyle |= LVS_EX_ONECLICKACTIVATE | LVS_EX_TRACKSELECT;
+
+  exStyle |= LVS_EX_FULLROWSELECT;
+  if (exStyle != 0)
+    _listView.SetExtendedListViewStyle(exStyle);
+
+
+  SetText(Title);
+
+  const int kWidth = 400;
+  
+  LVCOLUMN columnInfo;
+  columnInfo.mask = LVCF_FMT | LVCF_WIDTH | LVCF_SUBITEM;
+  columnInfo.fmt = LVCFMT_LEFT;
+  columnInfo.iSubItem = 0;
+  columnInfo.cx = kWidth;
+  columnInfo.pszText = NULL; // (TCHAR *)(const TCHAR *)""; // "Property"
+
+  if (NumColumns > 1)
+  {
+    columnInfo.cx = 100;
+    /*
+    // Windows always uses LVCFMT_LEFT for first column.
+    // if we need LVCFMT_RIGHT, we can create dummy column and then remove it
+
+    // columnInfo.mask |= LVCF_TEXT;
+    _listView.InsertColumn(0, &columnInfo);
+  
+    columnInfo.iSubItem = 1;
+    columnInfo.fmt = LVCFMT_RIGHT;
+    _listView.InsertColumn(1, &columnInfo);
+    _listView.DeleteColumn(0);
+    */
+  }
+  // else
+    _listView.InsertColumn(0, &columnInfo);
+
+  if (NumColumns > 1)
+  {
+    // columnInfo.fmt = LVCFMT_LEFT;
+    columnInfo.cx = kWidth - columnInfo.cx;
+    columnInfo.iSubItem = 1;
+    // columnInfo.pszText = NULL; // (TCHAR *)(const TCHAR *)""; // "Value"
+    _listView.InsertColumn(1, &columnInfo);
+  }
+
+
+  UString s;
+  
+  FOR_VECTOR (i, Strings)
+  {
+    _listView.InsertItem(i, Strings[i]);
+
+    if (NumColumns > 1 && i < Values.Size())
+    {
+      s = Values[i];
+      if (s.Len() > kOneStringMaxSize)
+      {
+        s.DeleteFrom(kOneStringMaxSize);
+        s += " ...";
+      }
+      s.Replace(L"\r\n", L" ");
+      s.Replace(L"\n", L" ");
+      _listView.SetSubItem(i, 1, s);
+    }
+  }
+
+  if (SelectFirst && Strings.Size() > 0)
+    _listView.SetItemState_FocusedSelected(0);
+
+  _listView.SetColumnWidthAuto(0);
+  if (NumColumns > 1)
+    _listView.SetColumnWidthAuto(1);
+  StringsWereChanged = false;
+
+  NormalizeSize();
+  return CModalDialog::OnInit();
+}
+
+bool CListViewDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+  int mx, my;
+  GetMargins(8, mx, my);
+  int bx1, bx2, by;
+  GetItemSizes(IDCANCEL, bx1, by);
+  GetItemSizes(IDOK, bx2, by);
+  int y = ySize - my - by;
+  int x = xSize - mx - bx1;
+
+  /*
+  RECT rect;
+  GetClientRect(&rect);
+  rect.top = y - my;
+  InvalidateRect(&rect);
+  */
+  InvalidateRect(NULL);
+
+  MoveItem(IDCANCEL, x, y, bx1, by);
+  MoveItem(IDOK, x - mx - bx2, y, bx2, by);
+  /*
+  if (wParam == SIZE_MAXSHOW || wParam == SIZE_MAXIMIZED || wParam == SIZE_MAXHIDE)
+    mx = 0;
+  */
+  _listView.Move(mx, my, xSize - mx * 2, y - my * 2);
+  return false;
+}
+
+
+extern bool g_LVN_ITEMACTIVATE_Support;
+
+void CListViewDialog::CopyToClipboard()
+{
+  CUIntVector indexes;
+  ListView_GetSelected(_listView, indexes);
+  UString s;
+  
+  FOR_VECTOR (i, indexes)
+  {
+    unsigned index = indexes[i];
+    s += Strings[index];
+    if (NumColumns > 1 && index < Values.Size())
+    {
+      const UString &v = Values[index];
+      // if (!v.IsEmpty())
+      {
+        s += ": ";
+        s += v;
+      }
+    }
+    // if (indexes.Size() > 1)
+    {
+      s +=
+        #ifdef _WIN32
+          "\r\n"
+        #else
+          "\n"
+        #endif
+        ;
+    }
+  }
+  
+  ClipboardSetText(*this, s);
+}
+
+
+void CListViewDialog::ShowItemInfo()
+{
+  CUIntVector indexes;
+  ListView_GetSelected(_listView, indexes);
+  if (indexes.Size() != 1)
+    return;
+  unsigned index = indexes[0];
+
+  CEditDialog dlg;
+  if (NumColumns == 1)
+    dlg.Text = Strings[index];
+  else
+  {
+    dlg.Title = Strings[index];
+    if (index < Values.Size())
+      dlg.Text = Values[index];
+  }
+  
+  #ifdef _WIN32
+  if (dlg.Text.Find(L'\r') < 0)
+    dlg.Text.Replace(L"\n", L"\r\n");
+  #endif
+
+  dlg.Create(*this);
+}
+
+
+void CListViewDialog::DeleteItems()
+{
+  for (;;)
+  {
+    int index = _listView.GetNextSelectedItem(-1);
+    if (index < 0)
+      break;
+    StringsWereChanged = true;
+    _listView.DeleteItem(index);
+    if ((unsigned)index < Strings.Size())
+      Strings.Delete(index);
+    if ((unsigned)index < Values.Size())
+      Values.Delete(index);
+  }
+  int focusedIndex = _listView.GetFocusedItem();
+  if (focusedIndex >= 0)
+    _listView.SetItemState_FocusedSelected(focusedIndex);
+  _listView.SetColumnWidthAuto(0);
+}
+
+
+void CListViewDialog::OnEnter()
+{
+  if (IsKeyDown(VK_MENU)
+      || NumColumns > 1)
+  {
+    ShowItemInfo();
+    return;
+  }
+  OnOK();
+}
+
+bool CListViewDialog::OnNotify(UINT /* controlID */, LPNMHDR header)
+{
+  if (header->hwndFrom != _listView)
+    return false;
+  switch (header->code)
+  {
+    case LVN_ITEMACTIVATE:
+      if (g_LVN_ITEMACTIVATE_Support)
+      {
+        OnEnter();
+        return true;
+      }
+      break;
+    case NM_DBLCLK:
+    case NM_RETURN: // probabably it's unused
+      if (!g_LVN_ITEMACTIVATE_Support)
+      {
+        OnEnter();
+        return true;
+      }
+      break;
+
+    case LVN_KEYDOWN:
+    {
+      LPNMLVKEYDOWN keyDownInfo = LPNMLVKEYDOWN(header);
+      switch (keyDownInfo->wVKey)
+      {
+        case VK_DELETE:
+        {
+          if (!DeleteIsAllowed)
+            return false;
+          DeleteItems();
+          return true;
+        }
+        case 'A':
+        {
+          if (IsKeyDown(VK_CONTROL))
+          {
+            _listView.SelectAll();
+            return true;
+          }
+          break;
+        }
+        case VK_INSERT:
+        case 'C':
+        {
+          if (IsKeyDown(VK_CONTROL))
+          {
+            CopyToClipboard();
+            return true;
+          }
+          break;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+void CListViewDialog::OnOK()
+{
+  FocusedItemIndex = _listView.GetFocusedItem();
+  CModalDialog::OnOK();
+}
diff --git a/CPP/7zip/UI/FileManager/ListViewDialog.h b/CPP/7zip/UI/FileManager/ListViewDialog.h
new file mode 100644
index 0000000..00206af
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ListViewDialog.h
@@ -0,0 +1,46 @@
+// ListViewDialog.h
+
+#ifndef __LISTVIEW_DIALOG_H
+#define __LISTVIEW_DIALOG_H
+
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/ListView.h"
+
+#include "ListViewDialogRes.h"
+
+class CListViewDialog: public NWindows::NControl::CModalDialog
+{
+  NWindows::NControl::CListView _listView;
+  virtual void OnOK();
+  virtual bool OnInit();
+  virtual bool OnSize(WPARAM wParam, int xSize, int ySize);
+  virtual bool OnNotify(UINT controlID, LPNMHDR header);
+  void CopyToClipboard();
+  void DeleteItems();
+  void ShowItemInfo();
+  void OnEnter();
+public:
+  UString Title;
+  
+  bool SelectFirst;
+  bool DeleteIsAllowed;
+  bool StringsWereChanged;
+  
+  UStringVector Strings;
+  UStringVector Values;
+  
+  int FocusedItemIndex;
+  unsigned NumColumns;
+
+  INT_PTR Create(HWND wndParent = 0) { return CModalDialog::Create(IDD_LISTVIEW, wndParent); }
+
+  CListViewDialog():
+    SelectFirst(false),
+    DeleteIsAllowed(false),
+    StringsWereChanged(false),
+    FocusedItemIndex(-1),
+    NumColumns(1)
+    {}
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/ListViewDialog.rc b/CPP/7zip/UI/FileManager/ListViewDialog.rc
new file mode 100644
index 0000000..4343b75
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ListViewDialog.rc
@@ -0,0 +1,14 @@
+#include "ListViewDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 480
+#define yc 320
+
+IDD_LISTVIEW  DIALOG  0, 0, xs, ys  MY_MODAL_RESIZE_DIALOG_STYLE  MY_FONT
+CAPTION "ListView"
+{
+  CONTROL  "List1", IDL_LISTVIEW, "SysListView32", LVS_REPORT | LVS_SHOWSELALWAYS |
+            LVS_AUTOARRANGE | LVS_NOCOLUMNHEADER | WS_BORDER | WS_TABSTOP,
+            m, m, xc, yc - bys - m
+  OK_CANCEL
+}
diff --git a/CPP/7zip/UI/FileManager/ListViewDialogRes.h b/CPP/7zip/UI/FileManager/ListViewDialogRes.h
new file mode 100644
index 0000000..9abdb9d
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ListViewDialogRes.h
@@ -0,0 +1,2 @@
+#define IDD_LISTVIEW  99
+#define IDL_LISTVIEW 100
diff --git a/CPP/7zip/UI/FileManager/MenuPage.cpp b/CPP/7zip/UI/FileManager/MenuPage.cpp
new file mode 100644
index 0000000..05f24d7
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MenuPage.cpp
@@ -0,0 +1,362 @@
+// MenuPage.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/ZipRegistry.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileFind.h"
+
+#include "../Explorer/ContextMenuFlags.h"
+#include "../Explorer/RegistryContextMenu.h"
+#include "../Explorer/resource.h"
+
+#include "../FileManager/PropertyNameRes.h"
+
+#include "../GUI/ExtractDialogRes.h"
+
+#include "FormatUtils.h"
+#include "HelpUtils.h"
+#include "LangUtils.h"
+#include "MenuPage.h"
+#include "MenuPageRes.h"
+
+
+using namespace NWindows;
+using namespace NContextMenuFlags;
+
+static const UInt32 kLangIDs[] =
+{
+  IDX_SYSTEM_INTEGRATE_TO_MENU,
+  IDX_SYSTEM_CASCADED_MENU,
+  IDX_SYSTEM_ICON_IN_MENU,
+  IDX_EXTRACT_ELIM_DUP,
+  IDT_SYSTEM_CONTEXT_MENU_ITEMS
+};
+
+#define kMenuTopic "fm/options.htm#sevenZip"
+
+struct CContextMenuItem
+{
+  int ControlID;
+  UInt32 Flag;
+};
+
+static const CContextMenuItem kMenuItems[] =
+{
+  { IDS_CONTEXT_OPEN, kOpen },
+  { IDS_CONTEXT_OPEN, kOpenAs },
+  { IDS_CONTEXT_EXTRACT, kExtract },
+  { IDS_CONTEXT_EXTRACT_HERE, kExtractHere },
+  { IDS_CONTEXT_EXTRACT_TO, kExtractTo },
+
+  { IDS_CONTEXT_TEST, kTest },
+
+  { IDS_CONTEXT_COMPRESS, kCompress },
+  { IDS_CONTEXT_COMPRESS_TO, kCompressTo7z },
+  { IDS_CONTEXT_COMPRESS_TO, kCompressToZip },
+
+  #ifndef UNDER_CE
+  { IDS_CONTEXT_COMPRESS_EMAIL, kCompressEmail },
+  { IDS_CONTEXT_COMPRESS_TO_EMAIL, kCompressTo7zEmail },
+  { IDS_CONTEXT_COMPRESS_TO_EMAIL, kCompressToZipEmail },
+  #endif
+
+  { IDS_PROP_CHECKSUM, kCRC },
+  { IDS_PROP_CHECKSUM, kCRC_Cascaded },
+};
+
+
+#if !defined(_WIN64)
+extern bool g_Is_Wow64;
+#endif
+
+#ifndef KEY_WOW64_64KEY
+  #define KEY_WOW64_64KEY (0x0100)
+#endif
+
+#ifndef KEY_WOW64_32KEY
+  #define KEY_WOW64_32KEY (0x0200)
+#endif
+
+bool CMenuPage::OnInit()
+{
+  _initMode = true;
+
+  Clear_MenuChanged();
+  
+  LangSetDlgItems(*this, kLangIDs, ARRAY_SIZE(kLangIDs));
+
+  #ifdef UNDER_CE
+
+  HideItem(IDX_SYSTEM_INTEGRATE_TO_MENU);
+  HideItem(IDX_SYSTEM_INTEGRATE_TO_MENU_2);
+
+  #else
+
+  {
+    UString s;
+    {
+      CWindow window(GetItem(IDX_SYSTEM_INTEGRATE_TO_MENU));
+      window.GetText(s);
+    }
+    UString bit64 = LangString(IDS_PROP_BIT64);
+    if (bit64.IsEmpty())
+      bit64 = "64-bit";
+    #ifdef _WIN64
+      bit64.Replace(L"64", L"32");
+    #endif
+    s.Add_Space();
+    s += '(';
+    s += bit64;
+    s += ')';
+    SetItemText(IDX_SYSTEM_INTEGRATE_TO_MENU_2, s);
+  }
+
+  const FString prefix = NDLL::GetModuleDirPrefix();
+  
+  _dlls[0].ctrl = IDX_SYSTEM_INTEGRATE_TO_MENU;
+  _dlls[1].ctrl = IDX_SYSTEM_INTEGRATE_TO_MENU_2;
+  
+  _dlls[0].wow = 0;
+  _dlls[1].wow =
+      #ifdef _WIN64
+        KEY_WOW64_32KEY
+      #else
+        KEY_WOW64_64KEY
+      #endif
+      ;
+
+  for (unsigned d = 0; d < 2; d++)
+  {
+    CShellDll &dll = _dlls[d];
+
+    dll.wasChanged = false;
+
+    #ifndef _WIN64
+    if (d != 0 && !g_Is_Wow64)
+    {
+      HideItem(dll.ctrl);
+      continue;
+    }
+    #endif
+
+    FString &path = dll.Path;
+    path = prefix;
+    path += (d == 0 ? "7-zip.dll" :
+        #ifdef _WIN64
+          "7-zip32.dll"
+        #else
+          "7-zip64.dll"
+        #endif
+        );
+
+
+    if (!NFile::NFind::DoesFileExist_Raw(path))
+    {
+      path.Empty();
+      EnableItem(dll.ctrl, false);
+    }
+    else
+    {
+      dll.prevValue = CheckContextMenuHandler(fs2us(path), dll.wow);
+      CheckButton(dll.ctrl, dll.prevValue);
+    }
+  }
+
+  #endif
+
+
+  CContextMenuInfo ci;
+  ci.Load();
+
+  CheckButton(IDX_SYSTEM_CASCADED_MENU, ci.Cascaded.Val);
+  CheckButton(IDX_SYSTEM_ICON_IN_MENU, ci.MenuIcons.Val);
+  CheckButton(IDX_EXTRACT_ELIM_DUP, ci.ElimDup.Val);
+
+  _listView.Attach(GetItem(IDL_SYSTEM_OPTIONS));
+
+  const UInt32 newFlags = LVS_EX_CHECKBOXES | LVS_EX_FULLROWSELECT;
+  _listView.SetExtendedListViewStyle(newFlags, newFlags);
+
+  _listView.InsertColumn(0, L"", 200);
+
+  for (unsigned i = 0; i < ARRAY_SIZE(kMenuItems); i++)
+  {
+    const CContextMenuItem &menuItem = kMenuItems[i];
+
+    UString s = LangString(menuItem.ControlID);
+    if (menuItem.Flag == kCRC)
+      s = "CRC SHA";
+    else if (menuItem.Flag == kCRC_Cascaded)
+      s = "7-Zip > CRC SHA";
+    if (menuItem.Flag == kOpenAs
+        || menuItem.Flag == kCRC
+        || menuItem.Flag == kCRC_Cascaded)
+      s += " >";
+
+    switch (menuItem.ControlID)
+    {
+      case IDS_CONTEXT_EXTRACT_TO:
+      {
+        s = MyFormatNew(s, LangString(IDS_CONTEXT_FOLDER));
+        break;
+      }
+      case IDS_CONTEXT_COMPRESS_TO:
+      case IDS_CONTEXT_COMPRESS_TO_EMAIL:
+      {
+        UString s2 = LangString(IDS_CONTEXT_ARCHIVE);
+        switch (menuItem.Flag)
+        {
+          case kCompressTo7z:
+          case kCompressTo7zEmail:
+            s2 += (".7z");
+            break;
+          case kCompressToZip:
+          case kCompressToZipEmail:
+            s2 += (".zip");
+            break;
+        }
+        s = MyFormatNew(s, s2);
+        break;
+      }
+    }
+
+    int itemIndex = _listView.InsertItem(i, s);
+    _listView.SetCheckState(itemIndex, ((ci.Flags & menuItem.Flag) != 0));
+  }
+
+  _listView.SetColumnWidthAuto(0);
+  _initMode = false;
+
+  return CPropertyPage::OnInit();
+}
+
+
+#ifndef UNDER_CE
+
+static void ShowMenuErrorMessage(const wchar_t *m, HWND hwnd)
+{
+  MessageBoxW(hwnd, m, L"7-Zip", MB_ICONERROR);
+}
+
+#endif
+
+
+LONG CMenuPage::OnApply()
+{
+  #ifndef UNDER_CE
+  
+  for (unsigned d = 2; d != 0;)
+  {
+    d--;
+    CShellDll &dll = _dlls[d];
+    if (dll.wasChanged && !dll.Path.IsEmpty())
+    {
+      bool newVal = IsButtonCheckedBool(dll.ctrl);
+      LONG res = SetContextMenuHandler(newVal, fs2us(dll.Path), dll.wow);
+      if (res != ERROR_SUCCESS && (dll.prevValue != newVal || newVal))
+        ShowMenuErrorMessage(NError::MyFormatMessage(res), *this);
+      dll.prevValue = CheckContextMenuHandler(fs2us(dll.Path), dll.wow);
+      CheckButton(dll.ctrl, dll.prevValue);
+      dll.wasChanged = false;
+    }
+  }
+
+  #endif
+
+  if (_cascaded_Changed || _menuIcons_Changed || _elimDup_Changed || _flags_Changed)
+  {
+    CContextMenuInfo ci;
+    ci.Cascaded.Val = IsButtonCheckedBool(IDX_SYSTEM_CASCADED_MENU);
+    ci.Cascaded.Def = _cascaded_Changed;
+
+    ci.MenuIcons.Val = IsButtonCheckedBool(IDX_SYSTEM_ICON_IN_MENU);
+    ci.MenuIcons.Def = _menuIcons_Changed;
+    
+    ci.ElimDup.Val = IsButtonCheckedBool(IDX_EXTRACT_ELIM_DUP);
+    ci.ElimDup.Def = _elimDup_Changed;
+
+    ci.Flags = 0;
+    
+    for (unsigned i = 0; i < ARRAY_SIZE(kMenuItems); i++)
+      if (_listView.GetCheckState(i))
+        ci.Flags |= kMenuItems[i].Flag;
+    
+    ci.Flags_Def = _flags_Changed;
+    ci.Save();
+
+    Clear_MenuChanged();
+  }
+
+  // UnChanged();
+
+  return PSNRET_NOERROR;
+}
+
+void CMenuPage::OnNotifyHelp()
+{
+  ShowHelpWindow(kMenuTopic);
+}
+
+bool CMenuPage::OnButtonClicked(int buttonID, HWND buttonHWND)
+{
+  switch (buttonID)
+  {
+    #ifndef UNDER_CE
+    case IDX_SYSTEM_INTEGRATE_TO_MENU:
+    case IDX_SYSTEM_INTEGRATE_TO_MENU_2:
+    {
+      for (unsigned d = 0; d < 2; d++)
+      {
+        CShellDll &dll = _dlls[d];
+        if (buttonID == dll.ctrl && !dll.Path.IsEmpty())
+          dll.wasChanged = true;
+      }
+      break;
+    }
+    #endif
+
+    case IDX_SYSTEM_CASCADED_MENU: _cascaded_Changed = true; break;
+    case IDX_SYSTEM_ICON_IN_MENU: _menuIcons_Changed = true; break;
+    case IDX_EXTRACT_ELIM_DUP: _elimDup_Changed = true; break;
+      
+    default:
+      return CPropertyPage::OnButtonClicked(buttonID, buttonHWND);
+  }
+  
+  Changed();
+  return true;
+}
+
+bool CMenuPage::OnNotify(UINT controlID, LPNMHDR lParam)
+{
+  if (lParam->hwndFrom == HWND(_listView))
+  {
+    switch (lParam->code)
+    {
+      case (LVN_ITEMCHANGED):
+        return OnItemChanged((const NMLISTVIEW *)lParam);
+    }
+  }
+  return CPropertyPage::OnNotify(controlID, lParam);
+}
+
+
+bool CMenuPage::OnItemChanged(const NMLISTVIEW *info)
+{
+  if (_initMode)
+    return true;
+  if ((info->uChanged & LVIF_STATE) != 0)
+  {
+    UINT oldState = info->uOldState & LVIS_STATEIMAGEMASK;
+    UINT newState = info->uNewState & LVIS_STATEIMAGEMASK;
+    if (oldState != newState)
+    {
+      _flags_Changed = true;
+      Changed();
+    }
+  }
+  return true;
+}
diff --git a/CPP/7zip/UI/FileManager/MenuPage.h b/CPP/7zip/UI/FileManager/MenuPage.h
new file mode 100644
index 0000000..3807d9d
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MenuPage.h
@@ -0,0 +1,52 @@
+// MenuPage.h
+ 
+#ifndef __MENU_PAGE_H
+#define __MENU_PAGE_H
+
+#include "../../../Windows/Control/PropertyPage.h"
+#include "../../../Windows/Control/ListView.h"
+
+struct CShellDll
+{
+  FString Path;
+  bool wasChanged;
+  bool prevValue;
+  int ctrl;
+  UInt32 wow;
+
+  CShellDll(): wasChanged (false), prevValue(false), ctrl(0), wow(0) {}
+};
+
+class CMenuPage: public NWindows::NControl::CPropertyPage
+{
+  bool _initMode;
+
+  bool _cascaded_Changed;
+  bool _menuIcons_Changed;
+  bool _elimDup_Changed;
+  bool _flags_Changed;
+
+  void Clear_MenuChanged()
+  {
+    _cascaded_Changed = false;
+    _menuIcons_Changed = false;
+    _elimDup_Changed = false;
+    _flags_Changed = false;
+  }
+  
+  #ifndef UNDER_CE
+  CShellDll _dlls[2];
+  #endif
+  
+  NWindows::NControl::CListView _listView;
+
+  virtual bool OnInit();
+  virtual void OnNotifyHelp();
+  virtual bool OnNotify(UINT controlID, LPNMHDR lParam);
+  virtual bool OnItemChanged(const NMLISTVIEW *info);
+  virtual LONG OnApply();
+  virtual bool OnButtonClicked(int buttonID, HWND buttonHWND);
+public:
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/MenuPage.rc b/CPP/7zip/UI/FileManager/MenuPage.rc
new file mode 100644
index 0000000..fc21107
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MenuPage.rc
@@ -0,0 +1,24 @@
+#include "MenuPageRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 240
+#define yc 252
+
+IDD_MENU  MY_PAGE
+#include "MenuPage2.rc"
+
+#ifdef UNDER_CE
+
+#undef m
+#undef xc
+#undef yc
+
+#define m 4
+#define xc (SMALL_PAGE_SIZE_X + 8)
+
+#define yc 112
+
+IDD_MENU_2  MY_PAGE
+#include "MenuPage2.rc"
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/MenuPage2.rc b/CPP/7zip/UI/FileManager/MenuPage2.rc
new file mode 100644
index 0000000..af86226
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MenuPage2.rc
@@ -0,0 +1,17 @@
+#include "../GUI/ExtractDialogRes.h"
+
+#define y 82
+
+CAPTION "7-Zip"
+BEGIN
+  CONTROL  "Integrate 7-Zip to shell context menu", IDX_SYSTEM_INTEGRATE_TO_MENU, MY_CHECKBOX, m, m, xc, 10
+  CONTROL  "(32-bit)", IDX_SYSTEM_INTEGRATE_TO_MENU_2, MY_CHECKBOX, m, m + 14, xc, 10
+  CONTROL  "Cascaded context menu", IDX_SYSTEM_CASCADED_MENU, MY_CHECKBOX, m, m + 28, xc, 10
+  CONTROL  "Icons in context menu", IDX_SYSTEM_ICON_IN_MENU, MY_CHECKBOX, m, m + 42, xc, 10
+  CONTROL   "Eliminate duplication of root folder", IDX_EXTRACT_ELIM_DUP, MY_CHECKBOX, m, m + 56, xc, 10
+
+  LTEXT    "Context menu items:", IDT_SYSTEM_CONTEXT_MENU_ITEMS, m, m + 70, xc, 8
+  CONTROL  "List", IDL_SYSTEM_OPTIONS, "SysListView32",
+           LVS_REPORT | LVS_SINGLESEL | LVS_NOCOLUMNHEADER | WS_BORDER | WS_TABSTOP,
+           m, m + y, xc, yc - y
+END
diff --git a/CPP/7zip/UI/FileManager/MenuPageRes.h b/CPP/7zip/UI/FileManager/MenuPageRes.h
new file mode 100644
index 0000000..ae0bf66
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MenuPageRes.h
@@ -0,0 +1,11 @@
+#define IDD_MENU     2300
+#define IDD_MENU_2  12300
+
+#define IDX_SYSTEM_INTEGRATE_TO_MENU    2301
+#define IDX_SYSTEM_CASCADED_MENU        2302
+#define IDT_SYSTEM_CONTEXT_MENU_ITEMS   2303
+#define IDX_SYSTEM_ICON_IN_MENU         2304
+
+#define IDX_SYSTEM_INTEGRATE_TO_MENU_2  2310
+
+#define IDL_SYSTEM_OPTIONS  100
diff --git a/CPP/7zip/UI/FileManager/MessagesDialog.cpp b/CPP/7zip/UI/FileManager/MessagesDialog.cpp
new file mode 100644
index 0000000..4124827
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MessagesDialog.cpp
@@ -0,0 +1,76 @@
+// MessagesDialog.cpp
+ 
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+
+#include "../../../Windows/ResourceString.h"
+
+#include "MessagesDialog.h"
+
+#include "LangUtils.h"
+
+#include "ProgressDialog2Res.h"
+
+using namespace NWindows;
+
+void CMessagesDialog::AddMessageDirect(LPCWSTR message)
+{
+  int i = _messageList.GetItemCount();
+  wchar_t sz[16];
+  ConvertUInt32ToString((UInt32)i, sz);
+  _messageList.InsertItem(i, sz);
+  _messageList.SetSubItem(i, 1, message);
+}
+
+void CMessagesDialog::AddMessage(LPCWSTR message)
+{
+  UString s = message;
+  while (!s.IsEmpty())
+  {
+    int pos = s.Find(L'\n');
+    if (pos < 0)
+      break;
+    AddMessageDirect(s.Left(pos));
+    s.DeleteFrontal(pos + 1);
+  }
+  AddMessageDirect(s);
+}
+
+bool CMessagesDialog::OnInit()
+{
+  #ifdef LANG
+  LangSetWindowText(*this, IDD_MESSAGES);
+  LangSetDlgItems(*this, NULL, 0);
+  SetItemText(IDOK, LangString(IDS_CLOSE));
+  #endif
+  _messageList.Attach(GetItem(IDL_MESSAGE));
+  _messageList.SetUnicodeFormat();
+
+  _messageList.InsertColumn(0, L"", 30);
+  _messageList.InsertColumn(1, LangString(IDS_MESSAGE), 600);
+
+  FOR_VECTOR (i, *Messages)
+    AddMessage((*Messages)[i]);
+
+  _messageList.SetColumnWidthAuto(0);
+  _messageList.SetColumnWidthAuto(1);
+  NormalizeSize();
+  return CModalDialog::OnInit();
+}
+
+bool CMessagesDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+  int mx, my;
+  GetMargins(8, mx, my);
+  int bx, by;
+  GetItemSizes(IDOK, bx, by);
+  int y = ySize - my - by;
+  int x = xSize - mx - bx;
+
+  InvalidateRect(NULL);
+
+  MoveItem(IDOK, x, y, bx, by);
+  _messageList.Move(mx, my, xSize - mx * 2, y - my * 2);
+  return false;
+}
diff --git a/CPP/7zip/UI/FileManager/MessagesDialog.h b/CPP/7zip/UI/FileManager/MessagesDialog.h
new file mode 100644
index 0000000..5c017eb
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MessagesDialog.h
@@ -0,0 +1,25 @@
+// MessagesDialog.h
+
+#ifndef __MESSAGES_DIALOG_H
+#define __MESSAGES_DIALOG_H
+
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/ListView.h"
+
+#include "MessagesDialogRes.h"
+
+class CMessagesDialog: public NWindows::NControl::CModalDialog
+{
+  NWindows::NControl::CListView _messageList;
+  
+  void AddMessageDirect(LPCWSTR message);
+  void AddMessage(LPCWSTR message);
+  virtual bool OnInit();
+  virtual bool OnSize(WPARAM wParam, int xSize, int ySize);
+public:
+  const UStringVector *Messages;
+  
+  INT_PTR Create(HWND parent = 0) { return CModalDialog::Create(IDD_MESSAGES, parent); }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/MessagesDialog.rc b/CPP/7zip/UI/FileManager/MessagesDialog.rc
new file mode 100644
index 0000000..49b73e8
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MessagesDialog.rc
@@ -0,0 +1,14 @@
+#include "MessagesDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 440
+#define yc 160
+
+IDD_MESSAGES  DIALOG  0, 0, xs, ys  MY_MODAL_RESIZE_DIALOG_STYLE  MY_FONT
+CAPTION "7-Zip: Diagnostic messages"
+{
+  DEFPUSHBUTTON "&Close", IDOK, bx, by, bxs, bys
+  CONTROL "List1", IDL_MESSAGE, "SysListView32",
+          LVS_REPORT | LVS_SHOWSELALWAYS | LVS_NOSORTHEADER | WS_BORDER | WS_TABSTOP,
+          m, m, xc, yc - bys - m
+}
diff --git a/CPP/7zip/UI/FileManager/MessagesDialogRes.h b/CPP/7zip/UI/FileManager/MessagesDialogRes.h
new file mode 100644
index 0000000..c8fffff
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MessagesDialogRes.h
@@ -0,0 +1,3 @@
+#define IDD_MESSAGES  6602
+#define IDS_MESSAGE   6603
+#define IDL_MESSAGE    100
diff --git a/CPP/7zip/UI/FileManager/Move.bmp b/CPP/7zip/UI/FileManager/Move.bmp
new file mode 100644
index 0000000..eb5f20f
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Move.bmp
diff --git a/CPP/7zip/UI/FileManager/Move2.bmp b/CPP/7zip/UI/FileManager/Move2.bmp
new file mode 100644
index 0000000..58679ef
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Move2.bmp
diff --git a/CPP/7zip/UI/FileManager/MyCom2.h b/CPP/7zip/UI/FileManager/MyCom2.h
new file mode 100644
index 0000000..c45c215
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MyCom2.h
@@ -0,0 +1,47 @@
+// MyCom2.h
+
+#ifndef __MYCOM2_H
+#define __MYCOM2_H
+
+#include "../../../Common/MyCom.h"
+
+#define MY_ADDREF_RELEASE_MT \
+STDMETHOD_(ULONG, AddRef)() { InterlockedIncrement((LONG *)&__m_RefCount); return __m_RefCount; } \
+STDMETHOD_(ULONG, Release)() { InterlockedDecrement((LONG *)&__m_RefCount); if (__m_RefCount != 0) \
+  return __m_RefCount; delete this; return 0; }
+
+#define MY_UNKNOWN_IMP_SPEC_MT2(i1, i) \
+  MY_QUERYINTERFACE_BEGIN \
+  MY_QUERYINTERFACE_ENTRY_UNKNOWN(i1) \
+  i \
+  MY_QUERYINTERFACE_END \
+  MY_ADDREF_RELEASE_MT
+
+
+#define MY_UNKNOWN_IMP1_MT(i) MY_UNKNOWN_IMP_SPEC_MT2( \
+  i, \
+  MY_QUERYINTERFACE_ENTRY(i) \
+  )
+
+#define MY_UNKNOWN_IMP2_MT(i1, i2) MY_UNKNOWN_IMP_SPEC_MT2( \
+  i1, \
+  MY_QUERYINTERFACE_ENTRY(i1) \
+  MY_QUERYINTERFACE_ENTRY(i2) \
+  )
+
+#define MY_UNKNOWN_IMP3_MT(i1, i2, i3) MY_UNKNOWN_IMP_SPEC_MT2( \
+  i1, \
+  MY_QUERYINTERFACE_ENTRY(i1) \
+  MY_QUERYINTERFACE_ENTRY(i2) \
+  MY_QUERYINTERFACE_ENTRY(i3) \
+  )
+
+#define MY_UNKNOWN_IMP4_MT(i1, i2, i3, i4) MY_UNKNOWN_IMP_SPEC_MT2( \
+  i1, \
+  MY_QUERYINTERFACE_ENTRY(i1) \
+  MY_QUERYINTERFACE_ENTRY(i2) \
+  MY_QUERYINTERFACE_ENTRY(i3) \
+  MY_QUERYINTERFACE_ENTRY(i4) \
+  )
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/MyLoadMenu.cpp b/CPP/7zip/UI/FileManager/MyLoadMenu.cpp
new file mode 100644
index 0000000..d87dfe3
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MyLoadMenu.cpp
@@ -0,0 +1,833 @@
+// MyLoadMenu.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/Menu.h"
+#include "../../../Windows/TimeUtils.h"
+#include "../../../Windows/Control/Dialog.h"
+
+#include "../../PropID.h"
+
+#include "../Common/CompressCall.h"
+
+#include "AboutDialog.h"
+#include "App.h"
+#include "HelpUtils.h"
+#include "LangUtils.h"
+#include "MyLoadMenu.h"
+#include "RegistryUtils.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+
+static const UINT kOpenBookmarkMenuID = 830;
+static const UINT kSetBookmarkMenuID = 810;
+static const UINT kMenuID_Time_Parent = 760;
+static const UINT kMenuID_Time = 761;
+
+extern HINSTANCE g_hInstance;
+
+#define kFMHelpTopic "FM/index.htm"
+
+extern void OptionsDialog(HWND hwndOwner, HINSTANCE hInstance);
+
+enum
+{
+  kMenuIndex_File = 0,
+  kMenuIndex_Edit,
+  kMenuIndex_View,
+  kMenuIndex_Bookmarks
+};
+
+static const UInt32 kTopMenuLangIDs[] = { 500, 501, 502, 503, 504, 505 };
+
+static const UInt32 kAddToFavoritesLangID = 800;
+static const UInt32 kToolbarsLangID = 733;
+
+static const CIDLangPair kIDLangPairs[] =
+{
+  { IDCLOSE, 557 },
+  { IDM_VIEW_ARANGE_BY_NAME, 1004 },
+  { IDM_VIEW_ARANGE_BY_TYPE, 1020 },
+  { IDM_VIEW_ARANGE_BY_DATE, 1012 },
+  { IDM_VIEW_ARANGE_BY_SIZE, 1007 }
+};
+
+static int FindLangItem(unsigned controlID)
+{
+  for (unsigned i = 0; i < ARRAY_SIZE(kIDLangPairs); i++)
+    if (kIDLangPairs[i].ControlID == controlID)
+      return i;
+  return -1;
+}
+
+static int GetSortControlID(PROPID propID)
+{
+  switch (propID)
+  {
+    case kpidName:       return IDM_VIEW_ARANGE_BY_NAME;
+    case kpidExtension:  return IDM_VIEW_ARANGE_BY_TYPE;
+    case kpidMTime:      return IDM_VIEW_ARANGE_BY_DATE;
+    case kpidSize:       return IDM_VIEW_ARANGE_BY_SIZE;
+    case kpidNoProperty: return IDM_VIEW_ARANGE_NO_SORT;
+  }
+  return -1;
+}
+
+/*
+static bool g_IsNew_fMask = true;
+
+class CInit_fMask
+{
+public:
+  CInit_fMask()
+  {
+    g_IsNew_fMask = false;
+    OSVERSIONINFO vi;
+    vi.dwOSVersionInfoSize = sizeof(vi);
+    if (::GetVersionEx(&vi))
+    {
+      g_IsNew_fMask = (vi.dwMajorVersion > 4 ||
+        (vi.dwMajorVersion == 4 && vi.dwMinorVersion > 0));
+    }
+    g_IsNew_fMask = false;
+  }
+} g_Init_fMask;
+
+// it's hack for supporting Windows NT
+// constants are from WinUser.h
+
+#if (WINVER < 0x0500)
+#define MIIM_STRING      0x00000040
+#define MIIM_BITMAP      0x00000080
+#define MIIM_FTYPE       0x00000100
+#endif
+
+static UINT Get_fMask_for_String()
+{
+  return g_IsNew_fMask ? MIIM_STRING : MIIM_TYPE;
+}
+
+static UINT Get_fMask_for_FType_and_String()
+{
+  return g_IsNew_fMask ? (MIIM_STRING | MIIM_FTYPE) : MIIM_TYPE;
+}
+*/
+
+static inline UINT Get_fMask_for_String() { return MIIM_TYPE; }
+static inline UINT Get_fMask_for_FType_and_String() { return MIIM_TYPE; }
+
+
+static void MyChangeMenu(HMENU menuLoc, int level, int menuIndex)
+{
+  CMenu menu;
+  menu.Attach(menuLoc);
+  
+  for (unsigned i = 0;; i++)
+  {
+    CMenuItem item;
+    item.fMask = Get_fMask_for_String() | MIIM_SUBMENU | MIIM_ID;
+    item.fType = MFT_STRING;
+    if (!menu.GetItem(i, true, item))
+      break;
+    {
+      UString newString;
+      if (item.hSubMenu)
+      {
+        UInt32 langID = 0;
+        if (level == 1 && menuIndex == kMenuIndex_Bookmarks)
+          langID = kAddToFavoritesLangID;
+        else
+        {
+          MyChangeMenu(item.hSubMenu, level + 1, i);
+          if (level == 1 && menuIndex == kMenuIndex_View)
+          {
+            if (item.wID == kMenuID_Time_Parent || item.StringValue.IsPrefixedBy_Ascii_NoCase("20"))
+              continue;
+            else
+              langID = kToolbarsLangID;
+          }
+          else if (level == 0 && i < ARRAY_SIZE(kTopMenuLangIDs))
+            langID = kTopMenuLangIDs[i];
+          else
+            continue;
+        }
+        
+        LangString_OnlyFromLangFile(langID, newString);
+        
+        if (newString.IsEmpty())
+          continue;
+      }
+      else
+      {
+        if (item.IsSeparator())
+          continue;
+        int langPos = FindLangItem(item.wID);
+
+        // we don't need lang change for CRC items!!!
+
+        UInt32 langID = langPos >= 0 ? kIDLangPairs[langPos].LangID : item.wID;
+        
+        if (langID == IDM_OPEN_INSIDE_ONE || langID == IDM_OPEN_INSIDE_PARSER)
+        {
+          LangString_OnlyFromLangFile(IDM_OPEN_INSIDE, newString);
+          if (newString.IsEmpty())
+            continue;
+          newString.Replace(L"&", L"");
+          int tabPos = newString.Find(L"\t");
+          if (tabPos >= 0)
+            newString.DeleteFrom(tabPos);
+          newString += (langID == IDM_OPEN_INSIDE_ONE ? " *" : " #");
+        }
+        else if (langID == IDM_BENCHMARK2)
+        {
+          LangString_OnlyFromLangFile(IDM_BENCHMARK, newString);
+          if (newString.IsEmpty())
+            continue;
+          newString.Replace(L"&", L"");
+          int tabPos = newString.Find(L"\t");
+          if (tabPos >= 0)
+            newString.DeleteFrom(tabPos);
+          newString += " 2";
+        }
+        else
+          LangString_OnlyFromLangFile(langID, newString);
+
+        if (newString.IsEmpty())
+          continue;
+
+        int tabPos = item.StringValue.ReverseFind(L'\t');
+        if (tabPos >= 0)
+          newString += item.StringValue.Ptr(tabPos);
+      }
+
+      {
+        item.StringValue = newString;
+        item.fMask = Get_fMask_for_String();
+        item.fType = MFT_STRING;
+        menu.SetItem(i, true, item);
+      }
+    }
+  }
+}
+
+static CMenu g_FileMenu;
+
+static struct CFileMenuDestroyer
+{
+  ~CFileMenuDestroyer() { if ((HMENU)g_FileMenu != 0) g_FileMenu.Destroy(); }
+} g_FileMenuDestroyer;
+
+
+static void CopyMenu(HMENU srcMenuSpec, HMENU destMenuSpec);
+
+static void CopyPopMenu_IfRequired(CMenuItem &item)
+{
+  if (item.hSubMenu)
+  {
+    CMenu popup;
+    popup.CreatePopup();
+    CopyMenu(item.hSubMenu, popup);
+    item.hSubMenu = popup;
+  }
+}
+
+static void CopyMenu(HMENU srcMenuSpec, HMENU destMenuSpec)
+{
+  CMenu srcMenu;
+  srcMenu.Attach(srcMenuSpec);
+  CMenu destMenu;
+  destMenu.Attach(destMenuSpec);
+  int startPos = 0;
+  for (int i = 0;; i++)
+  {
+    CMenuItem item;
+    item.fMask = MIIM_SUBMENU | MIIM_STATE | MIIM_ID | Get_fMask_for_FType_and_String();
+    item.fType = MFT_STRING;
+
+    if (!srcMenu.GetItem(i, true, item))
+      break;
+
+    CopyPopMenu_IfRequired(item);
+    if (destMenu.InsertItem(startPos, true, item))
+      startPos++;
+  }
+}
+
+void MyLoadMenu()
+{
+  HMENU baseMenu;
+
+  #ifdef UNDER_CE
+
+  HMENU oldMenu = g_App._commandBar.GetMenu(0);
+  if (oldMenu)
+    ::DestroyMenu(oldMenu);
+  /* BOOL b = */ g_App._commandBar.InsertMenubar(g_hInstance, IDM_MENU, 0);
+  baseMenu = g_App._commandBar.GetMenu(0);
+  // if (startInit)
+  // SetIdsForSubMenes(baseMenu, 0, 0);
+  if (!g_LangID.IsEmpty())
+    MyChangeMenu(baseMenu, 0, 0);
+  g_App._commandBar.DrawMenuBar(0);
+ 
+  #else
+
+  HWND hWnd = g_HWND;
+  HMENU oldMenu = ::GetMenu(hWnd);
+  ::SetMenu(hWnd, ::LoadMenu(g_hInstance, MAKEINTRESOURCE(IDM_MENU)));
+  ::DestroyMenu(oldMenu);
+  baseMenu = ::GetMenu(hWnd);
+  // if (startInit)
+  // SetIdsForSubMenes(baseMenu, 0, 0);
+  if (!g_LangID.IsEmpty())
+    MyChangeMenu(baseMenu, 0, 0);
+  ::DrawMenuBar(hWnd);
+
+  #endif
+
+  if ((HMENU)g_FileMenu != 0)
+    g_FileMenu.Destroy();
+  g_FileMenu.CreatePopup();
+  CopyMenu(::GetSubMenu(baseMenu, 0), g_FileMenu);
+}
+
+void OnMenuActivating(HWND /* hWnd */, HMENU hMenu, int position)
+{
+  HMENU mainMenu =
+    #ifdef UNDER_CE
+    g_App._commandBar.GetMenu(0);
+    #else
+    ::GetMenu(g_HWND)
+    #endif
+    ;
+  
+  if (::GetSubMenu(mainMenu, position) != hMenu)
+    return;
+  
+  if (position == kMenuIndex_File)
+  {
+    CMenu menu;
+    menu.Attach(hMenu);
+    menu.RemoveAllItems();
+    g_App.GetFocusedPanel().CreateFileMenu(hMenu);
+  }
+  else if (position == kMenuIndex_Edit)
+  {
+    /*
+    CMenu menu;
+    menu.Attach(hMenu);
+    menu.EnableItem(IDM_EDIT_CUT, MF_ENABLED);
+    menu.EnableItem(IDM_EDIT_COPY, MF_ENABLED);
+    menu.EnableItem(IDM_EDIT_PASTE, IsClipboardFormatAvailableHDROP() ? MF_ENABLED : MF_GRAYED);
+    */
+  }
+  else if (position == kMenuIndex_View)
+  {
+    // View;
+    CMenu menu;
+    menu.Attach(hMenu);
+    menu.CheckRadioItem(IDM_VIEW_LARGE_ICONS, IDM_VIEW_DETAILS,
+      IDM_VIEW_LARGE_ICONS + g_App.GetListViewMode(), MF_BYCOMMAND);
+
+    menu.CheckRadioItem(IDM_VIEW_ARANGE_BY_NAME, IDM_VIEW_ARANGE_NO_SORT,
+        GetSortControlID(g_App.GetSortID()), MF_BYCOMMAND);
+    
+    menu.CheckItemByID(IDM_VIEW_TWO_PANELS, g_App.NumPanels == 2);
+    menu.CheckItemByID(IDM_VIEW_FLAT_VIEW, g_App.GetFlatMode());
+    menu.CheckItemByID(IDM_VIEW_ARCHIVE_TOOLBAR, g_App.ShowArchiveToolbar);
+    menu.CheckItemByID(IDM_VIEW_STANDARD_TOOLBAR, g_App.ShowStandardToolbar);
+    menu.CheckItemByID(IDM_VIEW_TOOLBARS_LARGE_BUTTONS, g_App.LargeButtons);
+    menu.CheckItemByID(IDM_VIEW_TOOLBARS_SHOW_BUTTONS_TEXT, g_App.ShowButtonsLables);
+    menu.CheckItemByID(IDM_VIEW_AUTO_REFRESH, g_App.Get_AutoRefresh_Mode());
+    // menu.CheckItemByID(IDM_VIEW_SHOW_STREAMS, g_App.Get_ShowNtfsStrems_Mode());
+    // menu.CheckItemByID(IDM_VIEW_SHOW_DELETED, g_App.ShowDeletedFiles);
+
+    for (int i = 0;; i++)
+    {
+      CMenuItem item;
+      item.fMask = Get_fMask_for_String() | MIIM_SUBMENU | MIIM_ID;
+      item.fType = MFT_STRING;
+      if (!menu.GetItem(i, true, item))
+        break;
+      if (item.hSubMenu && (item.wID == kMenuID_Time_Parent
+          || item.StringValue.IsPrefixedBy_Ascii_NoCase("20")
+          ))
+      {
+        FILETIME ft;
+        NTime::GetCurUtcFileTime(ft);
+
+        {
+          wchar_t s[64];
+          s[0] = 0;
+          if (ConvertUtcFileTimeToString(ft, s, kTimestampPrintLevel_DAY))
+            item.StringValue = s;
+        }
+
+        item.fMask = Get_fMask_for_String() | MIIM_ID;
+        item.fType = MFT_STRING;
+        item.wID = kMenuID_Time_Parent;
+        menu.SetItem(i, true, item);
+
+        CMenu subMenu;
+        subMenu.Attach(menu.GetSubMenu(i));
+        subMenu.RemoveAllItems();
+        
+        const int k_TimeLevels[] =
+        {
+          kTimestampPrintLevel_DAY,
+          kTimestampPrintLevel_MIN,
+          kTimestampPrintLevel_SEC,
+          // 1,2,3,4,5,6,
+          kTimestampPrintLevel_NTFS
+        };
+
+        unsigned last = kMenuID_Time;
+        unsigned selectedCommand = 0;
+        g_App._timestampLevels.Clear();
+        unsigned id = kMenuID_Time;
+        
+        for (unsigned k = 0; k < ARRAY_SIZE(k_TimeLevels); k++)
+        {
+          wchar_t s[64];
+          s[0] = 0;
+          int timestampLevel = k_TimeLevels[k];
+          if (ConvertUtcFileTimeToString(ft, s, timestampLevel))
+          {
+            if (subMenu.AppendItem(MF_STRING, id, s))
+            {
+              last = id;
+              g_App._timestampLevels.Add(timestampLevel);
+              if (g_App.GetTimestampLevel() == timestampLevel)
+                selectedCommand = id;
+              id++;
+            }
+          }
+        }
+        if (selectedCommand != 0)
+          menu.CheckRadioItem(kMenuID_Time, last, selectedCommand, MF_BYCOMMAND);
+      }
+    }
+  }
+  else if (position == kMenuIndex_Bookmarks)
+  {
+    CMenu menu;
+    menu.Attach(hMenu);
+
+    CMenu subMenu;
+    subMenu.Attach(menu.GetSubMenu(0));
+    subMenu.RemoveAllItems();
+    int i;
+    
+    for (i = 0; i < 10; i++)
+    {
+      UString s = LangString(IDS_BOOKMARK);
+      s.Add_Space();
+      char c = (char)(L'0' + i);
+      s += c;
+      s += "\tAlt+Shift+";
+      s += c;
+      subMenu.AppendItem(MF_STRING, kSetBookmarkMenuID + i, s);
+    }
+
+    menu.RemoveAllItemsFrom(2);
+
+    for (i = 0; i < 10; i++)
+    {
+      UString s = g_App.AppState.FastFolders.GetString(i);
+      const int kMaxSize = 100;
+      const int kFirstPartSize = kMaxSize / 2;
+      if (s.Len() > kMaxSize)
+      {
+        s.Delete(kFirstPartSize, s.Len() - kMaxSize);
+        s.Insert(kFirstPartSize, L" ... ");
+      }
+      if (s.IsEmpty())
+        s = '-';
+      s += "\tAlt+";
+      s += (char)('0' + i);
+      menu.AppendItem(MF_STRING, kOpenBookmarkMenuID + i, s);
+    }
+  }
+}
+
+/*
+It doesn't help
+void OnMenuUnActivating(HWND hWnd, HMENU hMenu, int id)
+{
+  if (::GetSubMenu(::GetMenu(g_HWND), 0) != hMenu)
+    return;
+}
+*/
+
+static const unsigned g_Zvc_IDs[] =
+{
+  IDM_VER_EDIT,
+  IDM_VER_COMMIT,
+  IDM_VER_REVERT,
+  IDM_VER_DIFF
+};
+
+static const char * const g_Zvc_Strings[] =
+{
+    "Ver Edit (&1)"
+  , "Ver Commit"
+  , "Ver Revert"
+  , "Ver Diff (&0)"
+};
+
+void CFileMenu::Load(HMENU hMenu, unsigned startPos)
+{
+  CMenu destMenu;
+  destMenu.Attach(hMenu);
+
+  UString diffPath;
+  ReadRegDiff(diffPath);
+
+  unsigned numRealItems = startPos;
+
+  const bool isBigScreen = NControl::IsDialogSizeOK(40, 200, g_HWND);
+  
+  for (unsigned i = 0;; i++)
+  {
+    CMenuItem item;
+
+    item.fMask = MIIM_SUBMENU | MIIM_STATE | MIIM_ID | Get_fMask_for_FType_and_String();
+    item.fType = MFT_STRING;
+    
+    if (!g_FileMenu.GetItem(i, true, item))
+      break;
+    
+    {
+      if (!programMenu && item.wID == IDCLOSE)
+        continue;
+
+      if (item.wID == IDM_DIFF && diffPath.IsEmpty())
+        continue;
+
+      if (item.wID == IDM_OPEN_INSIDE_ONE || item.wID == IDM_OPEN_INSIDE_PARSER)
+      {
+        // We use diff as "super mode" marker for additional commands.
+        /*
+        if (diffPath.IsEmpty())
+          continue;
+        */
+      }
+
+      if (item.wID == IDM_BENCHMARK2)
+      {
+        // We use diff as "super mode" marker for additional commands.
+        if (diffPath.IsEmpty())
+          continue;
+      }
+
+      bool isOneFsFile = (isFsFolder && numItems == 1 && allAreFiles);
+      bool disable = (!isOneFsFile && (item.wID == IDM_SPLIT || item.wID == IDM_COMBINE));
+
+      if (readOnly)
+      {
+        switch (item.wID)
+        {
+          case IDM_RENAME:
+          case IDM_MOVE_TO:
+          case IDM_DELETE:
+          case IDM_COMMENT:
+          case IDM_CREATE_FOLDER:
+          case IDM_CREATE_FILE:
+            disable = true;
+        }
+      }
+      
+      if (isHashFolder)
+      {
+        switch (item.wID)
+        {
+          case IDM_OPEN:
+          case IDM_OPEN_INSIDE:
+          case IDM_OPEN_INSIDE_ONE:
+          case IDM_OPEN_INSIDE_PARSER:
+          case IDM_OPEN_OUTSIDE:
+          case IDM_FILE_VIEW:
+          case IDM_FILE_EDIT:
+          // case IDM_RENAME:
+          case IDM_COPY_TO:
+          case IDM_MOVE_TO:
+          // case IDM_DELETE:
+          case IDM_COMMENT:
+          case IDM_CREATE_FOLDER:
+          case IDM_CREATE_FILE:
+          case IDM_LINK:
+          case IDM_DIFF:
+            disable = true;
+        }
+      }
+
+
+      if (item.wID == IDM_LINK && numItems != 1)
+        disable = true;
+
+      if (item.wID == IDM_ALT_STREAMS)
+        disable = !isAltStreamsSupported;
+
+      if (!isBigScreen && (disable || item.IsSeparator()))
+        continue;
+
+      CopyPopMenu_IfRequired(item);
+      if (destMenu.InsertItem(startPos, true, item))
+      {
+        if (disable)
+          destMenu.EnableItem(startPos, MF_BYPOSITION | MF_GRAYED);
+        startPos++;
+      }
+
+      if (!item.IsSeparator())
+        numRealItems = startPos;
+    }
+  }
+
+  UString vercPath;
+  if (!diffPath.IsEmpty() && isFsFolder && allAreFiles && numItems == 1)
+    ReadReg_VerCtrlPath(vercPath);
+  
+  if (!vercPath.IsEmpty())
+  {
+    NFile::NFind::CFileInfo fi;
+    if (fi.Find(FilePath) && fi.Size < ((UInt32)1 << 31) && !fi.IsDir())
+    {
+      for (unsigned k = 0; k < ARRAY_SIZE(g_Zvc_IDs); k++)
+      {
+        const unsigned id = g_Zvc_IDs[k];
+        if (fi.IsReadOnly())
+        {
+          if (id == IDM_VER_COMMIT ||
+              id == IDM_VER_REVERT ||
+              id == IDM_VER_DIFF)
+            continue;
+        }
+        else
+        {
+          if (id == IDM_VER_EDIT)
+            continue;
+        }
+        
+        CMenuItem item;
+        UString s (g_Zvc_Strings[k]);
+        if (destMenu.AppendItem(MF_STRING, id, s))
+        {
+          startPos++;
+          numRealItems = startPos;
+        }
+      }
+    }
+  }
+  
+  destMenu.RemoveAllItemsFrom(numRealItems);
+}
+
+bool ExecuteFileCommand(unsigned id)
+{
+  if (id >= kMenuCmdID_Plugin_Start)
+  {
+    g_App.GetFocusedPanel().InvokePluginCommand(id);
+    g_App.GetFocusedPanel()._sevenZipContextMenu.Release();
+    g_App.GetFocusedPanel()._systemContextMenu.Release();
+    return true;
+  }
+
+  switch (id)
+  {
+    // File
+    case IDM_OPEN: g_App.OpenItem(); break;
+    
+    case IDM_OPEN_INSIDE:        g_App.OpenItemInside(NULL); break;
+    case IDM_OPEN_INSIDE_ONE:    g_App.OpenItemInside(L"*"); break;
+    case IDM_OPEN_INSIDE_PARSER: g_App.OpenItemInside(L"#"); break;
+
+    case IDM_OPEN_OUTSIDE: g_App.OpenItemOutside(); break;
+    case IDM_FILE_VIEW: g_App.EditItem(false); break;
+    case IDM_FILE_EDIT: g_App.EditItem(true); break;
+    case IDM_RENAME: g_App.Rename(); break;
+    case IDM_COPY_TO: g_App.CopyTo(); break;
+    case IDM_MOVE_TO: g_App.MoveTo(); break;
+    case IDM_DELETE: g_App.Delete(!IsKeyDown(VK_SHIFT)); break;
+    
+    case IDM_HASH_ALL: g_App.CalculateCrc("*"); break;
+    case IDM_CRC32: g_App.CalculateCrc("CRC32"); break;
+    case IDM_CRC64: g_App.CalculateCrc("CRC64"); break;
+    case IDM_SHA1: g_App.CalculateCrc("SHA1"); break;
+    case IDM_SHA256: g_App.CalculateCrc("SHA256"); break;
+    
+    case IDM_DIFF: g_App.DiffFiles(); break;
+
+    case IDM_VER_EDIT:
+    case IDM_VER_COMMIT:
+    case IDM_VER_REVERT:
+    case IDM_VER_DIFF:
+        g_App.VerCtrl(id); break;
+
+    case IDM_SPLIT: g_App.Split(); break;
+    case IDM_COMBINE: g_App.Combine(); break;
+    case IDM_PROPERTIES: g_App.Properties(); break;
+    case IDM_COMMENT: g_App.Comment(); break;
+    case IDM_CREATE_FOLDER: g_App.CreateFolder(); break;
+    case IDM_CREATE_FILE: g_App.CreateFile(); break;
+    #ifndef UNDER_CE
+    case IDM_LINK: g_App.Link(); break;
+    case IDM_ALT_STREAMS: g_App.OpenAltStreams(); break;
+    #endif
+    default: return false;
+  }
+  return true;
+}
+
+static void MyBenchmark(bool totalMode)
+{
+  CPanel::CDisableTimerProcessing disableTimerProcessing1(g_App.Panels[0]);
+  CPanel::CDisableTimerProcessing disableTimerProcessing2(g_App.Panels[1]);
+  Benchmark(totalMode);
+}
+
+bool OnMenuCommand(HWND hWnd, unsigned id)
+{
+  if (ExecuteFileCommand(id))
+    return true;
+
+  switch (id)
+  {
+    // File
+    case IDCLOSE:
+      SendMessage(hWnd, WM_ACTIVATE, MAKEWPARAM(WA_INACTIVE, 0), (LPARAM)hWnd);
+      g_ExitEventLauncher.Exit(false);
+      SendMessage(hWnd, WM_CLOSE, 0, 0);
+      break;
+    
+    // Edit
+    /*
+    case IDM_EDIT_CUT:
+      g_App.EditCut();
+      break;
+    case IDM_EDIT_COPY:
+      g_App.EditCopy();
+      break;
+    case IDM_EDIT_PASTE:
+      g_App.EditPaste();
+      break;
+    */
+    case IDM_SELECT_ALL:
+      g_App.SelectAll(true);
+      g_App.Refresh_StatusBar();
+      break;
+    case IDM_DESELECT_ALL:
+      g_App.SelectAll(false);
+      g_App.Refresh_StatusBar();
+      break;
+    case IDM_INVERT_SELECTION:
+      g_App.InvertSelection();
+      g_App.Refresh_StatusBar();
+      break;
+    case IDM_SELECT:
+      g_App.SelectSpec(true);
+      g_App.Refresh_StatusBar();
+      break;
+    case IDM_DESELECT:
+      g_App.SelectSpec(false);
+      g_App.Refresh_StatusBar();
+      break;
+    case IDM_SELECT_BY_TYPE:
+      g_App.SelectByType(true);
+      g_App.Refresh_StatusBar();
+      break;
+    case IDM_DESELECT_BY_TYPE:
+      g_App.SelectByType(false);
+      g_App.Refresh_StatusBar();
+      break;
+
+    //View
+    case IDM_VIEW_LARGE_ICONS:
+    case IDM_VIEW_SMALL_ICONS:
+    case IDM_VIEW_LIST:
+    case IDM_VIEW_DETAILS:
+    {
+      UINT index = id - IDM_VIEW_LARGE_ICONS;
+      if (index < 4)
+      {
+        g_App.SetListViewMode(index);
+        /*
+        CMenu menu;
+        menu.Attach(::GetSubMenu(::GetMenu(hWnd), kMenuIndex_View));
+        menu.CheckRadioItem(IDM_VIEW_LARGE_ICONS, IDM_VIEW_DETAILS,
+            id, MF_BYCOMMAND);
+        */
+      }
+      break;
+    }
+    case IDM_VIEW_ARANGE_BY_NAME: g_App.SortItemsWithPropID(kpidName); break;
+    case IDM_VIEW_ARANGE_BY_TYPE: g_App.SortItemsWithPropID(kpidExtension); break;
+    case IDM_VIEW_ARANGE_BY_DATE: g_App.SortItemsWithPropID(kpidMTime); break;
+    case IDM_VIEW_ARANGE_BY_SIZE: g_App.SortItemsWithPropID(kpidSize); break;
+    case IDM_VIEW_ARANGE_NO_SORT: g_App.SortItemsWithPropID(kpidNoProperty); break;
+
+    case IDM_OPEN_ROOT_FOLDER:    g_App.OpenRootFolder(); break;
+    case IDM_OPEN_PARENT_FOLDER:  g_App.OpenParentFolder(); break;
+    case IDM_FOLDERS_HISTORY:     g_App.FoldersHistory(); break;
+    case IDM_VIEW_FLAT_VIEW:      g_App.ChangeFlatMode(); break;
+    case IDM_VIEW_REFRESH:        g_App.RefreshView(); break;
+    case IDM_VIEW_AUTO_REFRESH:   g_App.Change_AutoRefresh_Mode(); break;
+
+    // case IDM_VIEW_SHOW_STREAMS:     g_App.Change_ShowNtfsStrems_Mode(); break;
+    /*
+    case IDM_VIEW_SHOW_DELETED:
+    {
+      g_App.Change_ShowDeleted();
+      bool isChecked = g_App.ShowDeletedFiles;
+      Save_ShowDeleted(isChecked);
+    }
+    */
+    
+    case IDM_VIEW_TWO_PANELS:       g_App.SwitchOnOffOnePanel(); break;
+    case IDM_VIEW_STANDARD_TOOLBAR: g_App.SwitchStandardToolbar(); break;
+    case IDM_VIEW_ARCHIVE_TOOLBAR:  g_App.SwitchArchiveToolbar(); break;
+
+    case IDM_VIEW_TOOLBARS_SHOW_BUTTONS_TEXT: g_App.SwitchButtonsLables(); break;
+    case IDM_VIEW_TOOLBARS_LARGE_BUTTONS:     g_App.SwitchLargeButtons(); break;
+
+    // Tools
+    case IDM_OPTIONS: OptionsDialog(hWnd, g_hInstance); break;
+          
+    case IDM_BENCHMARK: MyBenchmark(false); break;
+    case IDM_BENCHMARK2: MyBenchmark(true); break;
+
+    // Help
+    case IDM_HELP_CONTENTS:
+      ShowHelpWindow(kFMHelpTopic);
+      break;
+    case IDM_ABOUT:
+    {
+      CAboutDialog dialog;
+      dialog.Create(hWnd);
+      break;
+    }
+    default:
+    {
+      if (id >= kOpenBookmarkMenuID && id <= kOpenBookmarkMenuID + 9)
+      {
+        g_App.OpenBookmark(id - kOpenBookmarkMenuID);
+        return true;
+      }
+      else if (id >= kSetBookmarkMenuID && id <= kSetBookmarkMenuID + 9)
+      {
+        g_App.SetBookmark(id - kSetBookmarkMenuID);
+        return true;
+      }
+      else if (id >= kMenuID_Time && (unsigned)id <= kMenuID_Time + g_App._timestampLevels.Size())
+      {
+        unsigned index = id - kMenuID_Time;
+        g_App.SetTimestampLevel(g_App._timestampLevels[index]);
+        return true;
+      }
+      return false;
+    }
+  }
+  return true;
+}
diff --git a/CPP/7zip/UI/FileManager/MyLoadMenu.h b/CPP/7zip/UI/FileManager/MyLoadMenu.h
new file mode 100644
index 0000000..764bf7c
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MyLoadMenu.h
@@ -0,0 +1,40 @@
+// MyLoadMenu.h
+
+#ifndef __MY_LOAD_MENU_H
+#define __MY_LOAD_MENU_H
+
+void OnMenuActivating(HWND hWnd, HMENU hMenu, int position);
+// void OnMenuUnActivating(HWND hWnd, HMENU hMenu, int id);
+// void OnMenuUnActivating(HWND hWnd);
+
+bool OnMenuCommand(HWND hWnd, unsigned id);
+void MyLoadMenu();
+
+struct CFileMenu
+{
+  bool programMenu;
+  bool readOnly;
+  bool isHashFolder;
+  bool isFsFolder;
+  bool allAreFiles;
+  bool isAltStreamsSupported;
+  int numItems;
+  
+  FString FilePath;
+
+  CFileMenu():
+      programMenu(false),
+      readOnly(false),
+      isHashFolder(false),
+      isFsFolder(false),
+      allAreFiles(false),
+      isAltStreamsSupported(true),
+      numItems(0)
+    {}
+
+  void Load(HMENU hMenu, unsigned startPos);
+};
+
+bool ExecuteFileCommand(unsigned id);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/MyWindowsNew.h b/CPP/7zip/UI/FileManager/MyWindowsNew.h
new file mode 100644
index 0000000..48a9535
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MyWindowsNew.h
@@ -0,0 +1,76 @@
+// MyWindowsNew.h
+
+#ifndef __MY_WINDOWS_NEW_H
+#define __MY_WINDOWS_NEW_H
+
+#ifdef _MSC_VER
+
+#include <ShObjIdl.h>
+
+#ifndef __ITaskbarList3_INTERFACE_DEFINED__
+#define __ITaskbarList3_INTERFACE_DEFINED__
+
+typedef enum THUMBBUTTONFLAGS
+{
+  THBF_ENABLED = 0,
+  THBF_DISABLED = 0x1,
+  THBF_DISMISSONCLICK = 0x2,
+  THBF_NOBACKGROUND = 0x4,
+  THBF_HIDDEN = 0x8,
+  THBF_NONINTERACTIVE = 0x10
+} THUMBBUTTONFLAGS;
+
+typedef enum THUMBBUTTONMASK
+{
+  THB_BITMAP = 0x1,
+  THB_ICON = 0x2,
+  THB_TOOLTIP = 0x4,
+  THB_FLAGS = 0x8
+} THUMBBUTTONMASK;
+
+// #include <pshpack8.h>
+
+typedef struct THUMBBUTTON
+{
+  THUMBBUTTONMASK dwMask;
+  UINT iId;
+  UINT iBitmap;
+  HICON hIcon;
+  WCHAR szTip[260];
+  THUMBBUTTONFLAGS dwFlags;
+} THUMBBUTTON;
+
+typedef struct THUMBBUTTON *LPTHUMBBUTTON;
+
+typedef enum TBPFLAG
+{
+  TBPF_NOPROGRESS = 0,
+  TBPF_INDETERMINATE = 0x1,
+  TBPF_NORMAL = 0x2,
+  TBPF_ERROR = 0x4,
+  TBPF_PAUSED = 0x8
+} TBPFLAG;
+
+DEFINE_GUID(IID_ITaskbarList3, 0xEA1AFB91, 0x9E28, 0x4B86, 0x90, 0xE9, 0x9E, 0x9F, 0x8A, 0x5E, 0xEF, 0xAF);
+
+struct ITaskbarList3: public ITaskbarList2
+{
+  STDMETHOD(SetProgressValue)(HWND hwnd, ULONGLONG ullCompleted, ULONGLONG ullTotal) = 0;
+  STDMETHOD(SetProgressState)(HWND hwnd, TBPFLAG tbpFlags) = 0;
+  STDMETHOD(RegisterTab)(HWND hwndTab, HWND hwndMDI) = 0;
+  STDMETHOD(UnregisterTab)(HWND hwndTab) = 0;
+  STDMETHOD(SetTabOrder)(HWND hwndTab, HWND hwndInsertBefore) = 0;
+  STDMETHOD(SetTabActive)(HWND hwndTab, HWND hwndMDI, DWORD dwReserved) = 0;
+  STDMETHOD(ThumbBarAddButtons)(HWND hwnd, UINT cButtons, LPTHUMBBUTTON pButton) = 0;
+  STDMETHOD(ThumbBarUpdateButtons)(HWND hwnd, UINT cButtons, LPTHUMBBUTTON pButton) = 0;
+  STDMETHOD(ThumbBarSetImageList)(HWND hwnd, HIMAGELIST himl) = 0;
+  STDMETHOD(SetOverlayIcon)(HWND hwnd, HICON hIcon, LPCWSTR pszDescription) = 0;
+  STDMETHOD(SetThumbnailTooltip)(HWND hwnd, LPCWSTR pszTip) = 0;
+  STDMETHOD(SetThumbnailClip)(HWND hwnd, RECT *prcClip) = 0;
+};
+
+#endif
+
+#endif
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/NetFolder.cpp b/CPP/7zip/UI/FileManager/NetFolder.cpp
new file mode 100644
index 0000000..a941e73
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/NetFolder.cpp
@@ -0,0 +1,281 @@
+// NetFolder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/PropVariant.h"
+
+#include "../../PropID.h"
+
+#include "FSFolder.h"
+#include "NetFolder.h"
+#include "SysIconUtils.h"
+
+using namespace NWindows;
+using namespace NNet;
+
+static const Byte  kProps[] =
+{
+  kpidName,
+  kpidLocalName,
+  kpidComment,
+  kpidProvider
+};
+
+void CNetFolder::Init(const UString &path)
+{
+  /*
+  if (path.Len() > 2)
+  {
+    if (path[0] == L'\\' && path[1] == L'\\')
+    {
+      CResource netResource;
+      netResource.RemoteName = GetSystemString(path.Left(path.Len() - 1));
+      netResource.Scope = RESOURCE_GLOBALNET;
+      netResource.Type = RESOURCETYPE_DISK;
+      netResource.DisplayType = RESOURCEDISPLAYTYPE_SERVER;
+      netResource.Usage = RESOURCEUSAGE_CONTAINER;
+      Init(&netResource, 0, path);
+      return;
+    }
+  }
+  Init(0, 0 , L"");
+  */
+  CResourceW resource;
+  resource.RemoteNameIsDefined = true;
+  if (!path.IsEmpty())
+    resource.RemoteName.SetFrom(path, path.Len() - 1);
+  resource.ProviderIsDefined = false;
+  resource.LocalNameIsDefined = false;
+  resource.CommentIsDefined = false;
+  resource.Type = RESOURCETYPE_DISK;
+  resource.Scope = RESOURCE_GLOBALNET;
+  resource.Usage = 0;
+  resource.DisplayType = 0;
+  CResourceW destResource;
+  UString systemPathPart;
+  DWORD result = GetResourceInformation(resource, destResource, systemPathPart);
+  if (result == NO_ERROR)
+    Init(&destResource, 0, path);
+  else
+    Init(0, 0 , L"");
+  return;
+}
+
+void CNetFolder::Init(const NWindows::NNet::CResourceW *netResource,
+      IFolderFolder *parentFolder, const UString &path)
+{
+  _path = path;
+  if (netResource == 0)
+    _netResourcePointer = 0;
+  else
+  {
+    _netResource = *netResource;
+    _netResourcePointer = &_netResource;
+
+    // if (_netResource.DisplayType == RESOURCEDISPLAYTYPE_SERVER)
+    _path = _netResource.RemoteName;
+    
+    /* WinXP-64: When we move UP from Network share without _parentFolder chain,
+         we can get empty _netResource.RemoteName. Do we need to use Provider there ? */
+    if (_path.IsEmpty())
+      _path = _netResource.Provider;
+
+    if (!_path.IsEmpty())
+      _path.Add_PathSepar();
+  }
+  _parentFolder = parentFolder;
+}
+
+STDMETHODIMP CNetFolder::LoadItems()
+{
+  _items.Clear();
+  CEnum enumerator;
+
+  for (;;)
+  {
+    DWORD result = enumerator.Open(
+      RESOURCE_GLOBALNET,
+      RESOURCETYPE_DISK,
+      0,        // enumerate all resources
+      _netResourcePointer
+      );
+    if (result == NO_ERROR)
+      break;
+    if (result != ERROR_ACCESS_DENIED)
+      return result;
+    if (_netResourcePointer != 0)
+    result = AddConnection2(_netResource,
+        0, 0, CONNECT_INTERACTIVE);
+    if (result != NO_ERROR)
+      return result;
+  }
+
+  for (;;)
+  {
+    CResourceEx resource;
+    DWORD result = enumerator.Next(resource);
+    if (result == NO_ERROR)
+    {
+      if (!resource.RemoteNameIsDefined) // For Win 98, I don't know what's wrong
+        resource.RemoteName = resource.Comment;
+      resource.Name = resource.RemoteName;
+      int pos = resource.Name.ReverseFind_PathSepar();
+      if (pos >= 0)
+      {
+        // _path = resource.Name.Left(pos + 1);
+        resource.Name.DeleteFrontal(pos + 1);
+      }
+      _items.Add(resource);
+    }
+    else if (result == ERROR_NO_MORE_ITEMS)
+      break;
+    else
+      return result;
+  }
+
+  /*
+  It's too slow for some systems.
+  if (_netResourcePointer && _netResource.DisplayType == RESOURCEDISPLAYTYPE_SERVER)
+  {
+    for (char c = 'a'; c <= 'z'; c++)
+    {
+      CResourceEx resource;
+      resource.Name = UString(wchar_t(c)) + L'$';
+      resource.RemoteNameIsDefined = true;
+      resource.RemoteName = _path + resource.Name;
+
+      NFile::NFind::CFindFile findFile;
+      NFile::NFind::CFileInfo fileInfo;
+      if (!findFile.FindFirst(us2fs(resource.RemoteName) + FString(FCHAR_PATH_SEPARATOR) + FCHAR_ANY_MASK, fileInfo))
+        continue;
+      resource.Usage = RESOURCEUSAGE_CONNECTABLE;
+      resource.LocalNameIsDefined = false;
+      resource.CommentIsDefined = false;
+      resource.ProviderIsDefined = false;
+      _items.Add(resource);
+    }
+  }
+  */
+  return S_OK;
+}
+
+
+STDMETHODIMP CNetFolder::GetNumberOfItems(UInt32 *numItems)
+{
+  *numItems = _items.Size();
+  return S_OK;
+}
+
+STDMETHODIMP CNetFolder::GetProperty(UInt32 itemIndex, PROPID propID, PROPVARIANT *value)
+{
+  NCOM::CPropVariant prop;
+  const CResourceEx &item = _items[itemIndex];
+  switch (propID)
+  {
+    case kpidIsDir:  prop = true; break;
+    case kpidName:
+      // if (item.RemoteNameIsDefined)
+        prop = item.Name;
+      break;
+    case kpidLocalName:  if (item.LocalNameIsDefined) prop = item.LocalName; break;
+    case kpidComment: if (item.CommentIsDefined) prop = item.Comment; break;
+    case kpidProvider: if (item.ProviderIsDefined) prop = item.Provider; break;
+  }
+  prop.Detach(value);
+  return S_OK;
+}
+
+STDMETHODIMP CNetFolder::BindToFolder(UInt32 index, IFolderFolder **resultFolder)
+{
+  *resultFolder = 0;
+  const CResourceEx &resource = _items[index];
+  if (resource.Usage == RESOURCEUSAGE_CONNECTABLE ||
+      resource.DisplayType == RESOURCEDISPLAYTYPE_SHARE)
+  {
+    NFsFolder::CFSFolder *fsFolderSpec = new NFsFolder::CFSFolder;
+    CMyComPtr<IFolderFolder> subFolder = fsFolderSpec;
+    RINOK(fsFolderSpec->Init(us2fs(resource.RemoteName + WCHAR_PATH_SEPARATOR))); // , this
+    *resultFolder = subFolder.Detach();
+  }
+  else
+  {
+    CNetFolder *netFolder = new CNetFolder;
+    CMyComPtr<IFolderFolder> subFolder = netFolder;
+    netFolder->Init(&resource, this, resource.Name + WCHAR_PATH_SEPARATOR);
+    *resultFolder = subFolder.Detach();
+  }
+  return S_OK;
+}
+
+STDMETHODIMP CNetFolder::BindToFolder(const wchar_t * /* name */, IFolderFolder ** /* resultFolder */)
+{
+  return E_NOTIMPL;
+}
+
+STDMETHODIMP CNetFolder::BindToParentFolder(IFolderFolder **resultFolder)
+{
+  *resultFolder = 0;
+  if (_parentFolder)
+  {
+    CMyComPtr<IFolderFolder> parentFolder = _parentFolder;
+    *resultFolder = parentFolder.Detach();
+    return S_OK;
+  }
+  if (_netResourcePointer != 0)
+  {
+    CResourceW resourceParent;
+    DWORD result = GetResourceParent(_netResource, resourceParent);
+    if (result != NO_ERROR)
+      return result;
+    if (!_netResource.RemoteNameIsDefined)
+      return S_OK;
+
+    CNetFolder *netFolder = new CNetFolder;
+    CMyComPtr<IFolderFolder> subFolder = netFolder;
+    netFolder->Init(&resourceParent, 0, WSTRING_PATH_SEPARATOR);
+    *resultFolder = subFolder.Detach();
+  }
+  return S_OK;
+}
+
+IMP_IFolderFolder_Props(CNetFolder)
+
+STDMETHODIMP CNetFolder::GetFolderProperty(PROPID propID, PROPVARIANT *value)
+{
+  NWindows::NCOM::CPropVariant prop;
+  switch (propID)
+  {
+    case kpidType: prop = "NetFolder"; break;
+    case kpidPath: prop = _path; break;
+  }
+  prop.Detach(value);
+  return S_OK;
+}
+
+STDMETHODIMP CNetFolder::GetSystemIconIndex(UInt32 index, Int32 *iconIndex)
+{
+  if (index >= (UInt32)_items.Size())
+    return E_INVALIDARG;
+  *iconIndex = 0;
+  const CResourceW &resource = _items[index];
+  int iconIndexTemp;
+  if (resource.DisplayType == RESOURCEDISPLAYTYPE_SERVER ||
+      resource.Usage == RESOURCEUSAGE_CONNECTABLE)
+  {
+    if (GetRealIconIndex(us2fs(resource.RemoteName), 0, iconIndexTemp))
+    {
+      *iconIndex = iconIndexTemp;
+      return S_OK;
+    }
+  }
+  else
+  {
+    if (GetRealIconIndex(FTEXT(""), FILE_ATTRIBUTE_DIRECTORY, iconIndexTemp))
+    {
+      *iconIndex = iconIndexTemp;
+      return S_OK;
+    }
+    // *anIconIndex = GetRealIconIndex(0, L"\\\\HOME");
+  }
+  return GetLastError();
+}
diff --git a/CPP/7zip/UI/FileManager/NetFolder.h b/CPP/7zip/UI/FileManager/NetFolder.h
new file mode 100644
index 0000000..151dd09
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/NetFolder.h
@@ -0,0 +1,40 @@
+// NetFolder.h
+
+#ifndef __NET_FOLDER_H
+#define __NET_FOLDER_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../../Windows/Net.h"
+
+#include "IFolder.h"
+
+struct CResourceEx: public NWindows::NNet::CResourceW
+{
+  UString Name;
+};
+
+class CNetFolder:
+  public IFolderFolder,
+  public IFolderGetSystemIconIndex,
+  public CMyUnknownImp
+{
+  NWindows::NNet::CResourceW _netResource;
+  NWindows::NNet::CResourceW *_netResourcePointer;
+
+  CObjectVector<CResourceEx> _items;
+
+  CMyComPtr<IFolderFolder> _parentFolder;
+  UString _path;
+public:
+  MY_UNKNOWN_IMP1(IFolderGetSystemIconIndex)
+  INTERFACE_FolderFolder(;)
+  STDMETHOD(GetSystemIconIndex)(UInt32 index, Int32 *iconIndex);
+
+  CNetFolder(): _netResourcePointer(0) {}
+  void Init(const UString &path);
+  void Init(const NWindows::NNet::CResourceW *netResource,
+      IFolderFolder *parentFolder, const UString &path);
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/OpenCallback.cpp b/CPP/7zip/UI/FileManager/OpenCallback.cpp
new file mode 100644
index 0000000..e2e03f5
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/OpenCallback.cpp
@@ -0,0 +1,129 @@
+// OpenCallback.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "../../Common/FileStreams.h"
+
+#include "../Common/ZipRegistry.h"
+
+#include "OpenCallback.h"
+#include "PasswordDialog.h"
+
+using namespace NWindows;
+
+STDMETHODIMP COpenArchiveCallback::SetTotal(const UInt64 *numFiles, const UInt64 *numBytes)
+{
+  RINOK(ProgressDialog.Sync.CheckStop());
+  {
+    // NSynchronization::CCriticalSectionLock lock(_criticalSection);
+    ProgressDialog.Sync.Set_NumFilesTotal(numFiles ? *numFiles : (UInt64)(Int64)-1);
+    // if (numFiles)
+    {
+      ProgressDialog.Sync.Set_BytesProgressMode(numFiles == NULL);
+    }
+    if (numBytes)
+      ProgressDialog.Sync.Set_NumBytesTotal(*numBytes);
+  }
+  return S_OK;
+}
+
+STDMETHODIMP COpenArchiveCallback::SetCompleted(const UInt64 *numFiles, const UInt64 *numBytes)
+{
+  // NSynchronization::CCriticalSectionLock lock(_criticalSection);
+  if (numFiles)
+    ProgressDialog.Sync.Set_NumFilesCur(*numFiles);
+  if (numBytes)
+    ProgressDialog.Sync.Set_NumBytesCur(*numBytes);
+  return ProgressDialog.Sync.CheckStop();
+}
+
+STDMETHODIMP COpenArchiveCallback::SetTotal(const UInt64 total)
+{
+  RINOK(ProgressDialog.Sync.CheckStop());
+  ProgressDialog.Sync.Set_NumBytesTotal(total);
+  return S_OK;
+}
+
+STDMETHODIMP COpenArchiveCallback::SetCompleted(const UInt64 *completed)
+{
+  return ProgressDialog.Sync.Set_NumBytesCur(completed);
+}
+
+STDMETHODIMP COpenArchiveCallback::GetProperty(PROPID propID, PROPVARIANT *value)
+{
+  NCOM::CPropVariant prop;
+  if (_subArchiveMode)
+  {
+    switch (propID)
+    {
+      case kpidName: prop = _subArchiveName; break;
+    }
+  }
+  else
+  {
+    switch (propID)
+    {
+      case kpidName:  prop = fs2us(_fileInfo.Name); break;
+      case kpidIsDir:  prop = _fileInfo.IsDir(); break;
+      case kpidSize:  prop = _fileInfo.Size; break;
+      case kpidAttrib:  prop = (UInt32)_fileInfo.Attrib; break;
+      case kpidCTime:  prop = _fileInfo.CTime; break;
+      case kpidATime:  prop = _fileInfo.ATime; break;
+      case kpidMTime:  prop = _fileInfo.MTime; break;
+    }
+  }
+  prop.Detach(value);
+  return S_OK;
+}
+
+STDMETHODIMP COpenArchiveCallback::GetStream(const wchar_t *name, IInStream **inStream)
+{
+  COM_TRY_BEGIN
+  *inStream = NULL;
+  if (_subArchiveMode)
+    return S_FALSE;
+
+  FString fullPath;
+  if (!NFile::NName::GetFullPath(_folderPrefix, us2fs(name), fullPath))
+    return S_FALSE;
+  if (!_fileInfo.Find_FollowLink(fullPath))
+    return S_FALSE;
+  if (_fileInfo.IsDir())
+    return S_FALSE;
+  CInFileStream *inFile = new CInFileStream;
+  CMyComPtr<IInStream> inStreamTemp = inFile;
+  if (!inFile->Open(fullPath))
+    return ::GetLastError();
+  *inStream = inStreamTemp.Detach();
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP COpenArchiveCallback::CryptoGetTextPassword(BSTR *password)
+{
+  COM_TRY_BEGIN
+  PasswordWasAsked = true;
+  if (!PasswordIsDefined)
+  {
+    CPasswordDialog dialog;
+    bool showPassword = NExtract::Read_ShowPassword();
+    dialog.ShowPassword = showPassword;
+   
+    ProgressDialog.WaitCreating();
+    if (dialog.Create(ProgressDialog) != IDOK)
+      return E_ABORT;
+
+    Password = dialog.Password;
+    PasswordIsDefined = true;
+    if (dialog.ShowPassword != showPassword)
+      NExtract::Save_ShowPassword(dialog.ShowPassword);
+  }
+  return StringToBstr(Password, password);
+  COM_TRY_END
+}
diff --git a/CPP/7zip/UI/FileManager/OpenCallback.h b/CPP/7zip/UI/FileManager/OpenCallback.h
new file mode 100644
index 0000000..9aa5d43
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/OpenCallback.h
@@ -0,0 +1,96 @@
+// OpenCallback.h
+
+#ifndef __OPEN_CALLBACK_H
+#define __OPEN_CALLBACK_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../../Windows/FileFind.h"
+
+#include "../../IPassword.h"
+
+#include "../../Archive/IArchive.h"
+
+#ifdef _SFX
+#include "ProgressDialog.h"
+#else
+#include "ProgressDialog2.h"
+#endif
+
+
+class COpenArchiveCallback:
+  public IArchiveOpenCallback,
+  public IArchiveOpenVolumeCallback,
+  public IArchiveOpenSetSubArchiveName,
+  public IProgress,
+  public ICryptoGetTextPassword,
+  public CMyUnknownImp
+{
+  FString _folderPrefix;
+  NWindows::NFile::NFind::CFileInfo _fileInfo;
+  // NWindows::NSynchronization::CCriticalSection _criticalSection;
+  bool _subArchiveMode;
+  UString _subArchiveName;
+
+public:
+  bool PasswordIsDefined;
+  bool PasswordWasAsked;
+  UString Password;
+  HWND ParentWindow;
+  CProgressDialog ProgressDialog;
+
+  MY_UNKNOWN_IMP5(
+    IArchiveOpenCallback,
+    IArchiveOpenVolumeCallback,
+    IArchiveOpenSetSubArchiveName,
+    IProgress,
+    ICryptoGetTextPassword)
+
+  INTERFACE_IProgress(;)
+  INTERFACE_IArchiveOpenCallback(;)
+  INTERFACE_IArchiveOpenVolumeCallback(;)
+
+  // ICryptoGetTextPassword
+  STDMETHOD(CryptoGetTextPassword)(BSTR *password);
+
+  STDMETHOD(SetSubArchiveName(const wchar_t *name))
+  {
+    _subArchiveMode = true;
+    _subArchiveName = name;
+    return S_OK;
+  }
+
+  COpenArchiveCallback():
+    ParentWindow(0)
+  {
+    _subArchiveMode = false;
+    PasswordIsDefined = false;
+    PasswordWasAsked = false;
+  }
+  /*
+  void Init()
+  {
+    PasswordIsDefined = false;
+    _subArchiveMode = false;
+  }
+  */
+  
+  HRESULT LoadFileInfo2(const FString &folderPrefix, const FString &fileName)
+  {
+    _folderPrefix = folderPrefix;
+    if (!_fileInfo.Find_FollowLink(_folderPrefix + fileName))
+    {
+      return GetLastError_noZero_HRESULT();
+    }
+    return S_OK;
+  }
+
+  void ShowMessage(const UInt64 *completed);
+
+  INT_PTR StartProgressDialog(const UString &title, NWindows::CThread &thread)
+  {
+    return ProgressDialog.Create(title, thread, ParentWindow);
+  }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/OptionsDialog.cpp b/CPP/7zip/UI/FileManager/OptionsDialog.cpp
new file mode 100644
index 0000000..c42e0f8
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/OptionsDialog.cpp
@@ -0,0 +1,87 @@
+// OptionsDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/PropertyPage.h"
+
+#include "DialogSize.h"
+
+#include "EditPage.h"
+#include "EditPageRes.h"
+#include "FoldersPage.h"
+#include "FoldersPageRes.h"
+#include "LangPage.h"
+#include "LangPageRes.h"
+#include "MenuPage.h"
+#include "MenuPageRes.h"
+#include "SettingsPage.h"
+#include "SettingsPageRes.h"
+#include "SystemPage.h"
+#include "SystemPageRes.h"
+
+#include "App.h"
+#include "LangUtils.h"
+#include "MyLoadMenu.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+
+void OptionsDialog(HWND hwndOwner, HINSTANCE hInstance);
+void OptionsDialog(HWND hwndOwner, HINSTANCE /* hInstance */)
+{
+  CSystemPage systemPage;
+  CMenuPage menuPage;
+  CFoldersPage foldersPage;
+  CEditPage editPage;
+  CSettingsPage settingsPage;
+  CLangPage langPage;
+
+  CObjectVector<NControl::CPageInfo> pages;
+  BIG_DIALOG_SIZE(200, 200);
+
+  const UINT pageIDs[] = {
+      SIZED_DIALOG(IDD_SYSTEM),
+      SIZED_DIALOG(IDD_MENU),
+      SIZED_DIALOG(IDD_FOLDERS),
+      SIZED_DIALOG(IDD_EDIT),
+      SIZED_DIALOG(IDD_SETTINGS),
+      SIZED_DIALOG(IDD_LANG) };
+
+  NControl::CPropertyPage *pagePointers[] = { &systemPage,  &menuPage, &foldersPage, &editPage, &settingsPage, &langPage };
+  
+  for (unsigned i = 0; i < ARRAY_SIZE(pageIDs); i++)
+  {
+    NControl::CPageInfo &page = pages.AddNew();
+    page.ID = pageIDs[i];
+    LangString_OnlyFromLangFile(page.ID, page.Title);
+    page.Page = pagePointers[i];
+  }
+
+  INT_PTR res = NControl::MyPropertySheet(pages, hwndOwner, LangString(IDS_OPTIONS));
+  
+  if (res != -1 && res != 0)
+  {
+    if (langPage.LangWasChanged)
+    {
+      // g_App._window.SetText(LangString(IDS_APP_TITLE, 0x03000000));
+      MyLoadMenu();
+      g_App.ReloadToolbars();
+      g_App.MoveSubWindows(); // we need it to change list window aafter _toolBar.AutoSize();
+      g_App.ReloadLang();
+    }
+  
+    /*
+    if (systemPage.WasChanged)
+    {
+      // probably it doesn't work, since image list is locked?
+      g_App.SysIconsWereChanged();
+    }
+    */
+    
+    g_App.SetListSettings();
+    g_App.RefreshAllPanels();
+    // ::PostMessage(hwndOwner, kLangWasChangedMessage, 0 , 0);
+  }
+}
diff --git a/CPP/7zip/UI/FileManager/OverwriteDialog.cpp b/CPP/7zip/UI/FileManager/OverwriteDialog.cpp
new file mode 100644
index 0000000..b455b14
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/OverwriteDialog.cpp
@@ -0,0 +1,138 @@
+// OverwriteDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/PropVariantConv.h"
+#include "../../../Windows/ResourceString.h"
+
+#include "../../../Windows/Control/Static.h"
+
+#include "FormatUtils.h"
+#include "LangUtils.h"
+#include "OverwriteDialog.h"
+
+#include "PropertyNameRes.h"
+
+using namespace NWindows;
+
+#ifdef LANG
+static const UInt32 kLangIDs[] =
+{
+  IDT_OVERWRITE_HEADER,
+  IDT_OVERWRITE_QUESTION_BEGIN,
+  IDT_OVERWRITE_QUESTION_END,
+  IDB_YES_TO_ALL,
+  IDB_NO_TO_ALL,
+  IDB_AUTO_RENAME
+};
+#endif
+
+static const unsigned kCurrentFileNameSizeLimit = 82;
+static const unsigned kCurrentFileNameSizeLimit2 = 30;
+
+void COverwriteDialog::ReduceString(UString &s)
+{
+  unsigned size = _isBig ? kCurrentFileNameSizeLimit : kCurrentFileNameSizeLimit2;
+  if (s.Len() > size)
+  {
+    s.Delete(size / 2, s.Len() - size);
+    s.Insert(size / 2, L" ... ");
+  }
+  if (!s.IsEmpty() && s.Back() == ' ')
+  {
+    // s += (wchar_t)(0x2423);
+    s.InsertAtFront(L'\"');
+    s += L'\"';
+  }
+}
+
+void COverwriteDialog::SetFileInfoControl(int textID, int iconID,
+    const NOverwriteDialog::CFileInfo &fileInfo)
+{
+  UString sizeString;
+  if (fileInfo.SizeIsDefined)
+    sizeString = MyFormatNew(IDS_FILE_SIZE, NumberToString(fileInfo.Size));
+
+  const UString &fileName = fileInfo.Name;
+  int slashPos = fileName.ReverseFind_PathSepar();
+  UString s1 = fileName.Left((unsigned)(slashPos + 1));
+  UString s2 = fileName.Ptr((unsigned)(slashPos + 1));
+
+  ReduceString(s1);
+  ReduceString(s2);
+  
+  UString s = s1;
+  s.Add_LF();
+  s += s2;
+  s.Add_LF();
+  s += sizeString;
+  s.Add_LF();
+
+  if (fileInfo.TimeIsDefined)
+  {
+    AddLangString(s, IDS_PROP_MTIME);
+    s += ": ";
+    char t[32];
+    ConvertUtcFileTimeToString(fileInfo.Time, t);
+    s += t;
+  }
+
+  NControl::CDialogChildControl control;
+  control.Init(*this, textID);
+  control.SetText(s);
+
+  SHFILEINFO shellFileInfo;
+  if (::SHGetFileInfo(
+      GetSystemString(fileInfo.Name), FILE_ATTRIBUTE_NORMAL, &shellFileInfo,
+      sizeof(shellFileInfo), SHGFI_ICON | SHGFI_USEFILEATTRIBUTES | SHGFI_LARGEICON))
+  {
+    NControl::CStatic staticContol;
+    staticContol.Attach(GetItem(iconID));
+    staticContol.SetIcon(shellFileInfo.hIcon);
+  }
+}
+
+bool COverwriteDialog::OnInit()
+{
+  #ifdef LANG
+  LangSetWindowText(*this, IDD_OVERWRITE);
+  LangSetDlgItems(*this, kLangIDs, ARRAY_SIZE(kLangIDs));
+  #endif
+  SetFileInfoControl(IDT_OVERWRITE_OLD_FILE_SIZE_TIME, IDI_OVERWRITE_OLD_FILE, OldFileInfo);
+  SetFileInfoControl(IDT_OVERWRITE_NEW_FILE_SIZE_TIME, IDI_OVERWRITE_NEW_FILE, NewFileInfo);
+  NormalizePosition();
+
+  if (!ShowExtraButtons)
+  {
+    HideItem(IDB_YES_TO_ALL);
+    HideItem(IDB_NO_TO_ALL);
+    HideItem(IDB_AUTO_RENAME);
+  }
+
+  if (DefaultButton_is_NO)
+  {
+    PostMsg(DM_SETDEFID, IDNO);
+    HWND h = GetItem(IDNO);
+    PostMsg(WM_NEXTDLGCTL, (WPARAM)h, TRUE);
+    // ::SetFocus(h);
+  }
+
+  return CModalDialog::OnInit();
+}
+
+bool COverwriteDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
+{
+  switch (buttonID)
+  {
+    case IDYES:
+    case IDNO:
+    case IDB_YES_TO_ALL:
+    case IDB_NO_TO_ALL:
+    case IDB_AUTO_RENAME:
+      End(buttonID);
+      return true;
+  }
+  return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+}
diff --git a/CPP/7zip/UI/FileManager/OverwriteDialog.h b/CPP/7zip/UI/FileManager/OverwriteDialog.h
new file mode 100644
index 0000000..24e56ca
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/OverwriteDialog.h
@@ -0,0 +1,79 @@
+// OverwriteDialog.h
+
+#ifndef __OVERWRITE_DIALOG_H
+#define __OVERWRITE_DIALOG_H
+
+#include "../../../Windows/Control/Dialog.h"
+
+#include "DialogSize.h"
+#include "OverwriteDialogRes.h"
+
+namespace NOverwriteDialog
+{
+  struct CFileInfo
+  {
+    bool SizeIsDefined;
+    bool TimeIsDefined;
+    UInt64 Size;
+    FILETIME Time;
+    UString Name;
+    
+    void SetTime(const FILETIME *t)
+    {
+      if (!t)
+        TimeIsDefined = false;
+      else
+      {
+        TimeIsDefined = true;
+        Time = *t;
+      }
+    }
+
+    void SetSize(UInt64 size)
+    {
+      SizeIsDefined = true;
+      Size = size;
+    }
+
+    void SetSize(const UInt64 *size)
+    {
+      if (!size)
+        SizeIsDefined = false;
+      else
+        SetSize(*size);
+    }
+  };
+}
+
+class COverwriteDialog: public NWindows::NControl::CModalDialog
+{
+  bool _isBig;
+
+  void SetFileInfoControl(int textID, int iconID, const NOverwriteDialog::CFileInfo &fileInfo);
+  virtual bool OnInit();
+  bool OnButtonClicked(int buttonID, HWND buttonHWND);
+  void ReduceString(UString &s);
+
+public:
+  bool ShowExtraButtons;
+  bool DefaultButton_is_NO;
+
+
+  COverwriteDialog(): ShowExtraButtons(true), DefaultButton_is_NO(false) {}
+
+  INT_PTR Create(HWND parent = 0)
+  {
+    BIG_DIALOG_SIZE(280, 200);
+    #ifdef UNDER_CE
+    _isBig = isBig;
+    #else
+    _isBig = true;
+    #endif
+    return CModalDialog::Create(SIZED_DIALOG(IDD_OVERWRITE), parent);
+  }
+
+  NOverwriteDialog::CFileInfo OldFileInfo;
+  NOverwriteDialog::CFileInfo NewFileInfo;
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/OverwriteDialog.rc b/CPP/7zip/UI/FileManager/OverwriteDialog.rc
new file mode 100644
index 0000000..29f9912
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/OverwriteDialog.rc
@@ -0,0 +1,91 @@
+#include "OverwriteDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 280
+#define yc 200
+
+#undef iconSize
+#define iconSize 24
+
+#undef x
+#undef fx
+#undef fy
+#define x (m + iconSize + m)
+#define fx (xc - iconSize - m)
+#define fy 50
+
+#define bSizeBig 104
+#undef bx1
+#define bx1 (xs - m - bSizeBig)
+
+IDD_OVERWRITE  DIALOG  0, 0, xs, ys  MY_MODAL_DIALOG_STYLE  MY_FONT
+CAPTION "Confirm File Replace"
+BEGIN
+  LTEXT  "Destination folder already contains processed file.", IDT_OVERWRITE_HEADER, m, 7, xc, 8
+  LTEXT  "Would you like to replace the existing file", IDT_OVERWRITE_QUESTION_BEGIN, m, 28, xc, 8
+  
+  ICON   "", IDI_OVERWRITE_OLD_FILE,             m,  44, iconSize, iconSize
+  LTEXT  "", IDT_OVERWRITE_OLD_FILE_SIZE_TIME,   x,  44, fx, fy, SS_NOPREFIX
+  
+  LTEXT  "with this one?", IDT_OVERWRITE_QUESTION_END, m,  98, xc, 8
+
+  ICON   "", IDI_OVERWRITE_NEW_FILE,             m, 114, iconSize, iconSize
+  LTEXT  "", IDT_OVERWRITE_NEW_FILE_SIZE_TIME,   x, 114, fx, fy, SS_NOPREFIX
+  
+  PUSHBUTTON  "&Yes",         IDYES,             bx3, by2, bxs, bys
+  PUSHBUTTON  "Yes to &All",  IDB_YES_TO_ALL,    bx2, by2, bxs, bys
+  PUSHBUTTON  "A&uto Rename", IDB_AUTO_RENAME,   bx1, by2, bSizeBig, bys
+  PUSHBUTTON  "&No",          IDNO,              bx3, by1, bxs, bys
+  PUSHBUTTON  "No to A&ll",   IDB_NO_TO_ALL,     bx2, by1, bxs, bys
+  PUSHBUTTON  "&Cancel",      IDCANCEL, xs - m - bxs, by1, bxs, bys
+END
+
+
+#ifdef UNDER_CE
+
+#undef m
+#undef xc
+#undef yc
+
+#define m 4
+#define xc 152
+#define yc 144
+
+#undef fy
+#define fy 40
+
+#undef  bxs
+#define bxs 48
+
+#undef bx1
+
+#define bx1 (xs - m - bxs)
+
+IDD_OVERWRITE_2  DIALOG  0, 0, xs, ys  MY_MODAL_DIALOG_STYLE  MY_FONT
+CAPTION "Confirm File Replace"
+BEGIN
+  LTEXT  "Would you like to replace the existing file", IDT_OVERWRITE_QUESTION_BEGIN, m, m, xc, 8
+  
+  ICON   "", IDI_OVERWRITE_OLD_FILE,             m,  20, iconSize, iconSize
+  LTEXT  "", IDT_OVERWRITE_OLD_FILE_SIZE_TIME,   x,  20, fx, fy, SS_NOPREFIX
+  
+  LTEXT  "with this one?", IDT_OVERWRITE_QUESTION_END, m,  60, xc, 8
+
+  ICON   "", IDI_OVERWRITE_NEW_FILE,             m,  72, iconSize, iconSize
+  LTEXT  "", IDT_OVERWRITE_NEW_FILE_SIZE_TIME,   x,  72, fx, fy, SS_NOPREFIX
+  
+  PUSHBUTTON  "&Yes",         IDYES,             bx3, by2, bxs, bys
+  PUSHBUTTON  "Yes to &All",  IDB_YES_TO_ALL,    bx2, by2, bxs, bys
+  PUSHBUTTON  "A&uto Rename", IDB_AUTO_RENAME,   bx1, by2, bxs, bys
+  PUSHBUTTON  "&No",          IDNO,              bx3, by1, bxs, bys
+  PUSHBUTTON  "No to A&ll",   IDB_NO_TO_ALL,     bx2, by1, bxs, bys
+  PUSHBUTTON  "&Cancel",      IDCANCEL,          bx1, by1, bxs, bys
+END
+
+#endif
+
+
+STRINGTABLE
+BEGIN
+  IDS_FILE_SIZE  "{0} bytes"
+END
diff --git a/CPP/7zip/UI/FileManager/OverwriteDialogRes.h b/CPP/7zip/UI/FileManager/OverwriteDialogRes.h
new file mode 100644
index 0000000..b480ba1
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/OverwriteDialogRes.h
@@ -0,0 +1,17 @@
+#define IDD_OVERWRITE     3500
+#define IDD_OVERWRITE_2  13500
+
+#define IDT_OVERWRITE_HEADER          3501
+#define IDT_OVERWRITE_QUESTION_BEGIN  3502
+#define IDT_OVERWRITE_QUESTION_END    3503
+#define IDS_FILE_SIZE                 3504
+
+#define IDB_AUTO_RENAME               3505
+#define IDB_YES_TO_ALL                 440
+#define IDB_NO_TO_ALL                  441
+
+#define IDI_OVERWRITE_OLD_FILE             100
+#define IDI_OVERWRITE_NEW_FILE             101
+
+#define IDT_OVERWRITE_OLD_FILE_SIZE_TIME   102
+#define IDT_OVERWRITE_NEW_FILE_SIZE_TIME   103
diff --git a/CPP/7zip/UI/FileManager/Panel.cpp b/CPP/7zip/UI/FileManager/Panel.cpp
new file mode 100644
index 0000000..e8c0b94
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Panel.cpp
@@ -0,0 +1,1113 @@
+// Panel.cpp
+
+#include "StdAfx.h"
+
+#include <WindowsX.h>
+// #include <stdio.h>
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/Thread.h"
+
+#include "../../PropID.h"
+
+#include "resource.h"
+#include "../GUI/ExtractRes.h"
+
+#include "../Common/ArchiveName.h"
+#include "../Common/CompressCall.h"
+
+#include "../Agent/IFolderArchive.h"
+
+#include "App.h"
+#include "ExtractCallback.h"
+#include "FSFolder.h"
+#include "FormatUtils.h"
+#include "Panel.h"
+#include "RootFolder.h"
+
+#include "PropertyNameRes.h"
+
+using namespace NWindows;
+using namespace NControl;
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+static const UINT_PTR kTimerID = 1;
+static const UINT kTimerElapse = 1000;
+
+static DWORD kStyles[4] = { LVS_ICON, LVS_SMALLICON, LVS_LIST, LVS_REPORT };
+
+// static const int kCreateFolderID = 101;
+
+extern HINSTANCE g_hInstance;
+extern DWORD g_ComCtl32Version;
+
+void CPanel::Release()
+{
+  // It's for unloading COM dll's: don't change it.
+  CloseOpenFolders();
+  _sevenZipContextMenu.Release();
+  _systemContextMenu.Release();
+}
+
+CPanel::~CPanel()
+{
+  CloseOpenFolders();
+}
+
+HWND CPanel::GetParent() const
+{
+  HWND h = CWindow2::GetParent();
+  return (h == 0) ? _mainWindow : h;
+}
+
+#define kClassName L"7-Zip::Panel"
+
+
+HRESULT CPanel::Create(HWND mainWindow, HWND parentWindow, UINT id,
+    const UString &currentFolderPrefix,
+    const UString &arcFormat,
+    CPanelCallback *panelCallback, CAppState *appState,
+    bool needOpenArc,
+    COpenResult &openRes)
+{
+  _mainWindow = mainWindow;
+  _processTimer = true;
+  _processNotify = true;
+  _processStatusBar = true;
+
+  _panelCallback = panelCallback;
+  _appState = appState;
+  // _index = index;
+  _baseID = id;
+  _comboBoxID = _baseID + 3;
+  _statusBarID = _comboBoxID + 1;
+
+  UString cfp = currentFolderPrefix;
+
+  if (!currentFolderPrefix.IsEmpty())
+    if (currentFolderPrefix[0] == L'.')
+    {
+      FString cfpF;
+      if (NFile::NDir::MyGetFullPathName(us2fs(currentFolderPrefix), cfpF))
+        cfp = fs2us(cfpF);
+    }
+
+  RINOK(BindToPath(cfp, arcFormat, openRes));
+
+  if (needOpenArc && !openRes.ArchiveIsOpened)
+    return S_OK;
+
+  if (!CreateEx(0, kClassName, 0, WS_CHILD | WS_VISIBLE,
+      0, 0, _xSize, 260,
+      parentWindow, (HMENU)(UINT_PTR)id, g_hInstance))
+    return E_FAIL;
+  PanelCreated = true;
+
+  return S_OK;
+}
+
+// extern UInt32 g_NumMessages;
+
+LRESULT CPanel::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+  // g_NumMessages++;
+  switch (message)
+  {
+    case kShiftSelectMessage:
+      OnShiftSelectMessage();
+      return 0;
+    case kReLoadMessage:
+      RefreshListCtrl(_selectedState);
+      return 0;
+    case kSetFocusToListView:
+      _listView.SetFocus();
+      return 0;
+    case kOpenItemChanged:
+      return OnOpenItemChanged(lParam);
+    case kRefresh_StatusBar:
+      if (_processStatusBar)
+        Refresh_StatusBar();
+      return 0;
+    #ifdef UNDER_CE
+    case kRefresh_HeaderComboBox:
+      LoadFullPathAndShow();
+      return 0;
+    #endif
+    case WM_TIMER:
+      OnTimer();
+      return 0;
+    case WM_CONTEXTMENU:
+      if (OnContextMenu(HANDLE(wParam), GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)))
+        return 0;
+      break;
+    /*
+    case WM_DROPFILES:
+      CompressDropFiles(HDROP(wParam));
+      return 0;
+    */
+  }
+  return CWindow2::OnMessage(message, wParam, lParam);
+}
+
+LRESULT CMyListView::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+  if (message == WM_CHAR)
+  {
+    UINT scanCode = (UINT)((lParam >> 16) & 0xFF);
+    bool extended = ((lParam & 0x1000000) != 0);
+    UINT virtualKey = MapVirtualKey(scanCode, 1);
+    if (virtualKey == VK_MULTIPLY || virtualKey == VK_ADD ||
+        virtualKey == VK_SUBTRACT)
+      return 0;
+    if ((wParam == '/' && extended)
+        || wParam == '\\' || wParam == '/')
+    {
+      _panel->OpenDrivesFolder();
+      return 0;
+    }
+  }
+  else if (message == WM_SYSCHAR)
+  {
+    // For Alt+Enter Beep disabling
+    UINT scanCode = (UINT)(lParam >> 16) & 0xFF;
+    UINT virtualKey = MapVirtualKey(scanCode, 1);
+    if (virtualKey == VK_RETURN || virtualKey == VK_MULTIPLY ||
+        virtualKey == VK_ADD || virtualKey == VK_SUBTRACT)
+      return 0;
+  }
+  /*
+  else if (message == WM_SYSKEYDOWN)
+  {
+    // return 0;
+  }
+  */
+  else if (message == WM_KEYDOWN)
+  {
+    bool alt = IsKeyDown(VK_MENU);
+    bool ctrl = IsKeyDown(VK_CONTROL);
+    bool shift = IsKeyDown(VK_SHIFT);
+    switch (wParam)
+    {
+      /*
+      case VK_RETURN:
+      {
+        if (shift && !alt && !ctrl)
+        {
+          _panel->OpenSelectedItems(false);
+          return 0;
+        }
+        break;
+      }
+      */
+      case VK_NEXT:
+      {
+        if (ctrl && !alt && !shift)
+        {
+          _panel->OpenFocusedItemAsInternal();
+          return 0;
+        }
+        break;
+      }
+      case VK_PRIOR:
+      if (ctrl && !alt && !shift)
+      {
+        _panel->OpenParentFolder();
+        return 0;
+      }
+    }
+  }
+  #ifdef UNDER_CE
+  else if (message == WM_KEYUP)
+  {
+    if (wParam == VK_F2) // it's VK_TSOFT2
+    {
+      // Activate Menu
+      ::PostMessage(g_HWND, WM_SYSCOMMAND, SC_KEYMENU, 0);
+      return 0;
+    }
+  }
+  #endif
+  else if (message == WM_SETFOCUS)
+  {
+    _panel->_lastFocusedIsList = true;
+    _panel->_panelCallback->PanelWasFocused();
+  }
+  return CListView2::OnMessage(message, wParam, lParam);
+}
+
+/*
+static LRESULT APIENTRY ComboBoxSubclassProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+  CWindow tempDialog(hwnd);
+  CMyComboBox *w = (CMyComboBox *)(tempDialog.GetUserDataLongPtr());
+  if (w == NULL)
+    return 0;
+  return w->OnMessage(message, wParam, lParam);
+}
+
+LRESULT CMyComboBox::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+  return CallWindowProc(_origWindowProc, *this, message, wParam, lParam);
+}
+*/
+
+#ifndef UNDER_CE
+
+static LRESULT APIENTRY ComboBoxEditSubclassProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+  CWindow tempDialog(hwnd);
+  CMyComboBoxEdit *w = (CMyComboBoxEdit *)(tempDialog.GetUserDataLongPtr());
+  if (w == NULL)
+    return 0;
+  return w->OnMessage(message, wParam, lParam);
+}
+
+#endif
+
+LRESULT CMyComboBoxEdit::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+  // See MSDN / Subclassing a Combo Box / Creating a Combo-box Toolbar
+  switch (message)
+  {
+    case WM_SYSKEYDOWN:
+      switch (wParam)
+      {
+        case VK_F1:
+        case VK_F2:
+        {
+          // check ALT
+          if ((lParam & (1<<29)) == 0)
+            break;
+          bool alt = IsKeyDown(VK_MENU);
+          bool ctrl = IsKeyDown(VK_CONTROL);
+          bool shift = IsKeyDown(VK_SHIFT);
+          if (alt && !ctrl && !shift)
+          {
+            _panel->_panelCallback->SetFocusToPath(wParam == VK_F1 ? 0 : 1);
+            return 0;
+          }
+          break;
+        }
+      }
+      break;
+    case WM_KEYDOWN:
+      switch (wParam)
+      {
+        case VK_TAB:
+          // SendMessage(hwndMain, WM_ENTER, 0, 0);
+          _panel->SetFocusToList();
+          return 0;
+        case VK_F9:
+        {
+          bool alt = IsKeyDown(VK_MENU);
+          bool ctrl = IsKeyDown(VK_CONTROL);
+          bool shift = IsKeyDown(VK_SHIFT);
+          if (!alt && !ctrl && !shift)
+          {
+            g_App.SwitchOnOffOnePanel();
+            return 0;
+          }
+          break;
+        }
+      }
+      break;
+    case WM_CHAR:
+      switch (wParam)
+      {
+        case VK_TAB:
+        case VK_ESCAPE:
+          return 0;
+      }
+  }
+  #ifndef _UNICODE
+  if (g_IsNT)
+    return CallWindowProcW(_origWindowProc, *this, message, wParam, lParam);
+  else
+  #endif
+    return CallWindowProc(_origWindowProc, *this, message, wParam, lParam);
+}
+
+bool CPanel::OnCreate(CREATESTRUCT * /* createStruct */)
+{
+  // _virtualMode = false;
+  // _sortIndex = 0;
+  _sortID = kpidName;
+  _ascending = true;
+  _lastFocusedIsList = true;
+
+  DWORD style = WS_CHILD | WS_VISIBLE; //  | WS_BORDER ; // | LVS_SHAREIMAGELISTS; //  | LVS_SHOWSELALWAYS;
+
+  style |= LVS_SHAREIMAGELISTS;
+  // style  |= LVS_AUTOARRANGE;
+  style |= WS_CLIPCHILDREN;
+  style |= WS_CLIPSIBLINGS;
+
+  const UInt32 kNumListModes = ARRAY_SIZE(kStyles);
+  if (_ListViewMode >= kNumListModes)
+    _ListViewMode = kNumListModes - 1;
+
+  style |= kStyles[_ListViewMode]
+    | WS_TABSTOP
+    | LVS_EDITLABELS;
+  if (_mySelectMode)
+    style |= LVS_SINGLESEL;
+
+  /*
+  if (_virtualMode)
+    style |= LVS_OWNERDATA;
+  */
+
+  DWORD exStyle;
+  exStyle = WS_EX_CLIENTEDGE;
+
+  if (!_listView.CreateEx(exStyle, style, 0, 0, 116, 260,
+      *this, (HMENU)(UINT_PTR)(_baseID + 1), g_hInstance, NULL))
+    return false;
+
+  _listView.SetUnicodeFormat();
+  _listView._panel = this;
+  _listView.SetWindowProc();
+
+  _listView.SetImageList(GetSysImageList(true), LVSIL_SMALL);
+  _listView.SetImageList(GetSysImageList(false), LVSIL_NORMAL);
+
+  // _exStyle |= LVS_EX_HEADERDRAGDROP;
+  // DWORD extendedStyle = _listView.GetExtendedListViewStyle();
+  // extendedStyle |= _exStyle;
+  //  _listView.SetExtendedListViewStyle(extendedStyle);
+  SetExtendedStyle();
+
+  _listView.Show(SW_SHOW);
+  _listView.InvalidateRect(NULL, true);
+  _listView.Update();
+  
+  // Ensure that the common control DLL is loaded.
+  INITCOMMONCONTROLSEX icex;
+
+  icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
+  icex.dwICC  = ICC_BAR_CLASSES;
+  InitCommonControlsEx(&icex);
+
+  TBBUTTON tbb [ ] =
+  {
+    // {0, 0, TBSTATE_ENABLED, BTNS_SEP, 0L, 0},
+    {VIEW_PARENTFOLDER, kParentFolderID, TBSTATE_ENABLED, BTNS_BUTTON, { 0, 0 }, 0, 0 },
+    // {0, 0, TBSTATE_ENABLED, BTNS_SEP, 0L, 0},
+    // {VIEW_NEWFOLDER, kCreateFolderID, TBSTATE_ENABLED, BTNS_BUTTON, 0L, 0},
+  };
+
+  #ifndef UNDER_CE
+  if (g_ComCtl32Version >= MAKELONG(71, 4))
+  #endif
+  {
+    icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
+    icex.dwICC  = ICC_COOL_CLASSES | ICC_BAR_CLASSES;
+    InitCommonControlsEx(&icex);
+    
+    // if there is no CCS_NOPARENTALIGN, there is space of some pixels after rebar (Incorrect GetWindowRect ?)
+
+    _headerReBar.Attach(::CreateWindowEx(WS_EX_TOOLWINDOW,
+      REBARCLASSNAME,
+      NULL, WS_VISIBLE | WS_BORDER | WS_CHILD |
+      WS_CLIPCHILDREN | WS_CLIPSIBLINGS
+      | CCS_NODIVIDER
+      | CCS_NOPARENTALIGN
+      | CCS_TOP
+      | RBS_VARHEIGHT
+      | RBS_BANDBORDERS
+      ,0,0,0,0, *this, NULL, g_hInstance, NULL));
+  }
+
+  DWORD toolbarStyle =  WS_CHILD | WS_VISIBLE ;
+  if (_headerReBar)
+  {
+    toolbarStyle |= 0
+      // | WS_CLIPCHILDREN
+      // | WS_CLIPSIBLINGS
+
+      | TBSTYLE_TOOLTIPS
+      | CCS_NODIVIDER
+      | CCS_NORESIZE
+      | TBSTYLE_FLAT
+      ;
+  }
+
+  _headerToolBar.Attach(::CreateToolbarEx ((*this), toolbarStyle,
+      _baseID + 2, 11,
+      (HINSTANCE)HINST_COMMCTRL,
+      IDB_VIEW_SMALL_COLOR,
+      (LPCTBBUTTON)&tbb, ARRAY_SIZE(tbb),
+      0, 0, 0, 0, sizeof (TBBUTTON)));
+
+  #ifndef UNDER_CE
+  // Load ComboBoxEx class
+  icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
+  icex.dwICC = ICC_USEREX_CLASSES;
+  InitCommonControlsEx(&icex);
+  #endif
+  
+  _headerComboBox.CreateEx(0,
+      #ifdef UNDER_CE
+      WC_COMBOBOXW
+      #else
+      WC_COMBOBOXEXW
+      #endif
+      , NULL,
+    WS_BORDER | WS_VISIBLE |WS_CHILD | CBS_DROPDOWN | CBS_AUTOHSCROLL,
+      0, 0, 100, 520,
+      ((_headerReBar == 0) ? (HWND)*this : _headerToolBar),
+      (HMENU)(UINT_PTR)(_comboBoxID),
+      g_hInstance, NULL);
+  #ifndef UNDER_CE
+  _headerComboBox.SetUnicodeFormat(true);
+
+  _headerComboBox.SetImageList(GetSysImageList(true));
+
+  _headerComboBox.SetExtendedStyle(CBES_EX_PATHWORDBREAKPROC, CBES_EX_PATHWORDBREAKPROC);
+
+  /*
+  _headerComboBox.SetUserDataLongPtr(LONG_PTR(&_headerComboBox));
+  _headerComboBox._panel = this;
+  _headerComboBox._origWindowProc =
+      (WNDPROC)_headerComboBox.SetLongPtr(GWLP_WNDPROC,
+      LONG_PTR(ComboBoxSubclassProc));
+  */
+  _comboBoxEdit.Attach(_headerComboBox.GetEditControl());
+
+  // _comboBoxEdit.SendMessage(CCM_SETUNICODEFORMAT, (WPARAM)(BOOL)TRUE, 0);
+
+  _comboBoxEdit.SetUserDataLongPtr(LONG_PTR(&_comboBoxEdit));
+  _comboBoxEdit._panel = this;
+   #ifndef _UNICODE
+   if (g_IsNT)
+     _comboBoxEdit._origWindowProc =
+      (WNDPROC)_comboBoxEdit.SetLongPtrW(GWLP_WNDPROC, LONG_PTR(ComboBoxEditSubclassProc));
+   else
+   #endif
+     _comboBoxEdit._origWindowProc =
+      (WNDPROC)_comboBoxEdit.SetLongPtr(GWLP_WNDPROC, LONG_PTR(ComboBoxEditSubclassProc));
+
+  #endif
+
+  if (_headerReBar)
+  {
+    REBARINFO     rbi;
+    rbi.cbSize = sizeof(REBARINFO);  // Required when using this struct.
+    rbi.fMask  = 0;
+    rbi.himl   = (HIMAGELIST)NULL;
+    _headerReBar.SetBarInfo(&rbi);
+    
+    // Send the TB_BUTTONSTRUCTSIZE message, which is required for
+    // backward compatibility.
+    // _headerToolBar.SendMessage(TB_BUTTONSTRUCTSIZE, (WPARAM)sizeof(TBBUTTON), 0);
+    SIZE size;
+    _headerToolBar.GetMaxSize(&size);
+    
+    REBARBANDINFO rbBand;
+    rbBand.cbSize = sizeof(REBARBANDINFO);  // Required
+    rbBand.fMask = RBBIM_STYLE | RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_SIZE;
+    rbBand.fStyle = RBBS_NOGRIPPER;
+    rbBand.cxMinChild = size.cx;
+    rbBand.cyMinChild = size.cy;
+    rbBand.cyChild = size.cy;
+    rbBand.cx = size.cx;
+    rbBand.hwndChild  = _headerToolBar;
+    _headerReBar.InsertBand(-1, &rbBand);
+
+    RECT rc;
+    ::GetWindowRect(_headerComboBox, &rc);
+    rbBand.cxMinChild = 30;
+    rbBand.cyMinChild = rc.bottom - rc.top;
+    rbBand.cx = 1000;
+    rbBand.hwndChild  = _headerComboBox;
+    _headerReBar.InsertBand(-1, &rbBand);
+    // _headerReBar.MaximizeBand(1, false);
+  }
+
+  _statusBar.Create(WS_CHILD | WS_VISIBLE, L"Status", (*this), _statusBarID);
+  // _statusBar2.Create(WS_CHILD | WS_VISIBLE, L"Status", (*this), _statusBarID + 1);
+
+  const int sizes[] = {220, 320, 420, -1};
+  _statusBar.SetParts(4, sizes);
+  // _statusBar2.SetParts(5, sizes);
+
+  /*
+  RECT rect;
+  GetClientRect(&rect);
+  OnSize(0, RECT_SIZE_X(rect), RECT_SIZE_Y(rect));
+  */
+
+  SetTimer(kTimerID, kTimerElapse);
+
+  // InitListCtrl();
+  RefreshListCtrl();
+  
+  return true;
+}
+
+void CPanel::OnDestroy()
+{
+  SaveListViewInfo();
+  CWindow2::OnDestroy();
+}
+
+void CPanel::ChangeWindowSize(int xSize, int ySize)
+{
+  if ((HWND)*this == 0)
+    return;
+  int kHeaderSize;
+  int kStatusBarSize;
+  // int kStatusBar2Size;
+  RECT rect;
+  if (_headerReBar)
+    _headerReBar.GetWindowRect(&rect);
+  else
+    _headerToolBar.GetWindowRect(&rect);
+
+  kHeaderSize = RECT_SIZE_Y(rect);
+
+  _statusBar.GetWindowRect(&rect);
+  kStatusBarSize = RECT_SIZE_Y(rect);
+  
+  // _statusBar2.GetWindowRect(&rect);
+  // kStatusBar2Size = RECT_SIZE_Y(rect);
+ 
+  int yListViewSize = MyMax(ySize - kHeaderSize - kStatusBarSize, 0);
+  const int kStartXPos = 32;
+  if (_headerReBar)
+  {
+  }
+  else
+  {
+    _headerToolBar.Move(0, 0, xSize, 0);
+    _headerComboBox.Move(kStartXPos, 2,
+        MyMax(xSize - kStartXPos - 10, kStartXPos), 0);
+  }
+  _listView.Move(0, kHeaderSize, xSize, yListViewSize);
+  _statusBar.Move(0, kHeaderSize + yListViewSize, xSize, kStatusBarSize);
+  // _statusBar2.MoveWindow(0, kHeaderSize + yListViewSize + kStatusBarSize, xSize, kStatusBar2Size);
+  // _statusBar.MoveWindow(0, 100, xSize, kStatusBarSize);
+  // _statusBar2.MoveWindow(0, 200, xSize, kStatusBar2Size);
+}
+
+bool CPanel::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+  if ((HWND)*this == 0)
+    return true;
+  if (_headerReBar)
+    _headerReBar.Move(0, 0, xSize, 0);
+  ChangeWindowSize(xSize, ySize);
+  return true;
+}
+
+bool CPanel::OnNotifyReBar(LPNMHDR header, LRESULT & /* result */)
+{
+  switch (header->code)
+  {
+    case RBN_HEIGHTCHANGE:
+    {
+      RECT rect;
+      GetWindowRect(&rect);
+      ChangeWindowSize(RECT_SIZE_X(rect), RECT_SIZE_Y(rect));
+      return false;
+    }
+  }
+  return false;
+}
+
+/*
+UInt32 g_OnNotify = 0;
+UInt32 g_LVIF_TEXT = 0;
+UInt32 g_Time = 0;
+
+void Print_OnNotify(const char *name)
+{
+  char s[256];
+  DWORD tim = GetTickCount();
+  sprintf(s,
+      "Time = %7u ms, Notify = %9u, TEXT = %9u, %s",
+      tim - g_Time,
+      g_OnNotify,
+      g_LVIF_TEXT,
+      name);
+  g_Time = tim;
+  OutputDebugStringA(s);
+  g_OnNotify = 0;
+  g_LVIF_TEXT = 0;
+}
+*/
+
+bool CPanel::OnNotify(UINT /* controlID */, LPNMHDR header, LRESULT &result)
+{
+  /*
+  g_OnNotify++;
+
+  if (header->hwndFrom == _listView)
+  {
+    if (header->code == LVN_GETDISPINFOW)
+    {
+      LV_DISPINFOW *dispInfo = (LV_DISPINFOW *)header;
+        if ((dispInfo->item.mask & LVIF_TEXT))
+          g_LVIF_TEXT++;
+    }
+  }
+  */
+
+  if (!_processNotify)
+    return false;
+
+  if (header->hwndFrom == _headerComboBox)
+    return OnNotifyComboBox(header, result);
+  else if (header->hwndFrom == _headerReBar)
+    return OnNotifyReBar(header, result);
+  else if (header->hwndFrom == _listView)
+    return OnNotifyList(header, result);
+  else if (::GetParent(header->hwndFrom) == _listView)
+  {
+    // NMHDR:code is UINT
+    // NM_RCLICK is unsigned in windows sdk
+    // NM_RCLICK is int      in MinGW
+    if (header->code == (UINT)NM_RCLICK)
+      return OnRightClick((MY_NMLISTVIEW_NMITEMACTIVATE *)header, result);
+  }
+  return false;
+}
+
+bool CPanel::OnCommand(int code, int itemID, LPARAM lParam, LRESULT &result)
+{
+  if (itemID == kParentFolderID)
+  {
+    OpenParentFolder();
+    result = 0;
+    return true;
+  }
+  /*
+  if (itemID == kCreateFolderID)
+  {
+    CreateFolder();
+    result = 0;
+    return true;
+  }
+  */
+  if (itemID == _comboBoxID)
+  {
+    if (OnComboBoxCommand(code, lParam, result))
+      return true;
+  }
+  return CWindow2::OnCommand(code, itemID, lParam, result);
+}
+
+
+
+/*
+void CPanel::MessageBox_Info(LPCWSTR message, LPCWSTR caption) const
+  { ::MessageBoxW((HWND)*this, message, caption, MB_OK); }
+void CPanel::MessageBox_Warning(LPCWSTR message) const
+  { ::MessageBoxW((HWND)*this, message, L"7-Zip", MB_OK | MB_ICONWARNING); }
+*/
+
+void CPanel::MessageBox_Error_Caption(LPCWSTR message, LPCWSTR caption) const
+  { ::MessageBoxW((HWND)*this, message, caption, MB_OK | MB_ICONSTOP); }
+
+void CPanel::MessageBox_Error(LPCWSTR message) const
+  { MessageBox_Error_Caption(message, L"7-Zip"); }
+
+static UString ErrorHResult_To_Message(HRESULT errorCode)
+{
+  if (errorCode == 0)
+    errorCode = E_FAIL;
+  return HResultToMessage(errorCode);
+}
+
+void CPanel::MessageBox_Error_HRESULT_Caption(HRESULT errorCode, LPCWSTR caption) const
+{
+  MessageBox_Error_Caption(ErrorHResult_To_Message(errorCode), caption);
+}
+
+void CPanel::MessageBox_Error_HRESULT(HRESULT errorCode) const
+  { MessageBox_Error_HRESULT_Caption(errorCode, L"7-Zip"); }
+
+void CPanel::MessageBox_Error_2Lines_Message_HRESULT(LPCWSTR message, HRESULT errorCode) const
+{
+  UString m = message;
+  m.Add_LF();
+  m += ErrorHResult_To_Message(errorCode);
+  MessageBox_Error(m);
+}
+
+void CPanel::MessageBox_LastError(LPCWSTR caption) const
+  { MessageBox_Error_HRESULT_Caption(::GetLastError(), caption); }
+
+void CPanel::MessageBox_LastError() const
+  { MessageBox_LastError(L"7-Zip"); }
+
+void CPanel::MessageBox_Error_LangID(UINT resourceID) const
+  { MessageBox_Error(LangString(resourceID)); }
+
+void CPanel::MessageBox_Error_UnsupportOperation() const
+  { MessageBox_Error_LangID(IDS_OPERATION_IS_NOT_SUPPORTED); }
+
+
+
+
+void CPanel::SetFocusToList()
+{
+  _listView.SetFocus();
+  // SetCurrentPathText();
+}
+
+void CPanel::SetFocusToLastRememberedItem()
+{
+  if (_lastFocusedIsList)
+    SetFocusToList();
+  else
+    _headerComboBox.SetFocus();
+}
+
+UString CPanel::GetFolderTypeID() const
+{
+  {
+    NCOM::CPropVariant prop;
+    if (_folder->GetFolderProperty(kpidType, &prop) == S_OK)
+      if (prop.vt == VT_BSTR)
+        return (const wchar_t *)prop.bstrVal;
+  }
+  return UString();
+}
+
+bool CPanel::IsFolderTypeEqTo(const char *s) const
+{
+  return StringsAreEqual_Ascii(GetFolderTypeID(), s);
+}
+
+bool CPanel::IsRootFolder() const { return IsFolderTypeEqTo("RootFolder"); }
+bool CPanel::IsFSFolder() const { return IsFolderTypeEqTo("FSFolder"); }
+bool CPanel::IsFSDrivesFolder() const { return IsFolderTypeEqTo("FSDrives"); }
+bool CPanel::IsAltStreamsFolder() const { return IsFolderTypeEqTo("AltStreamsFolder"); }
+bool CPanel::IsArcFolder() const
+{
+  return GetFolderTypeID().IsPrefixedBy_Ascii_NoCase("7-Zip");
+}
+
+bool CPanel::IsHashFolder() const
+{
+  if (_folder)
+  {
+    NCOM::CPropVariant prop;
+    if (_folder->GetFolderProperty(kpidIsHash, &prop) == S_OK)
+      if (prop.vt == VT_BOOL)
+        return VARIANT_BOOLToBool(prop.boolVal);
+  }
+  return false;
+}
+
+UString CPanel::GetFsPath() const
+{
+  if (IsFSDrivesFolder() && !IsDeviceDrivesPrefix() && !IsSuperDrivesPrefix())
+    return UString();
+  return _currentFolderPrefix;
+}
+
+UString CPanel::GetDriveOrNetworkPrefix() const
+{
+  if (!IsFSFolder())
+    return UString();
+  UString drive = GetFsPath();
+  drive.DeleteFrom(NFile::NName::GetRootPrefixSize(drive));
+  return drive;
+}
+
+void CPanel::SetListViewMode(UInt32 index)
+{
+  if (index >= 4)
+    return;
+  _ListViewMode = index;
+  DWORD oldStyle = (DWORD)_listView.GetStyle();
+  DWORD newStyle = kStyles[index];
+
+  // DWORD tickCount1 = GetTickCount();
+  if ((oldStyle & LVS_TYPEMASK) != newStyle)
+    _listView.SetStyle((oldStyle & ~LVS_TYPEMASK) | newStyle);
+  // RefreshListCtrlSaveFocused();
+  /*
+  DWORD tickCount2 = GetTickCount();
+  char s[256];
+  sprintf(s, "SetStyle = %5d",
+      tickCount2 - tickCount1
+      );
+  OutputDebugStringA(s);
+  */
+
+}
+
+void CPanel::ChangeFlatMode()
+{
+  _flatMode = !_flatMode;
+  if (_parentFolders.Size() > 0)
+    _flatModeForArc = _flatMode;
+  else
+    _flatModeForDisk = _flatMode;
+  RefreshListCtrl_SaveFocused();
+}
+
+/*
+void CPanel::Change_ShowNtfsStrems_Mode()
+{
+  _showNtfsStrems_Mode = !_showNtfsStrems_Mode;
+  if (_parentFolders.Size() > 0)
+    _showNtfsStrems_ModeForArc = _showNtfsStrems_Mode;
+  else
+    _showNtfsStrems_ModeForDisk = _showNtfsStrems_Mode;
+  RefreshListCtrlSaveFocused();
+}
+*/
+
+void CPanel::Post_Refresh_StatusBar()
+{
+  if (_processStatusBar)
+    PostMsg(kRefresh_StatusBar);
+}
+
+void CPanel::AddToArchive()
+{
+  CRecordVector<UInt32> indices;
+  GetOperatedItemIndices(indices);
+  if (!Is_IO_FS_Folder())
+  {
+    MessageBox_Error_UnsupportOperation();
+    return;
+  }
+  if (indices.Size() == 0)
+  {
+    MessageBox_Error_LangID(IDS_SELECT_FILES);
+    return;
+  }
+  UStringVector names;
+
+  const UString curPrefix = GetFsPath();
+  UString destCurDirPrefix = curPrefix;
+  if (IsFSDrivesFolder())
+    destCurDirPrefix = ROOT_FS_FOLDER;
+
+  FOR_VECTOR (i, indices)
+    names.Add(curPrefix + GetItemRelPath2(indices[i]));
+  
+  const UString arcName = CreateArchiveName(names);
+  
+  HRESULT res = CompressFiles(destCurDirPrefix, arcName, L"",
+      true, // addExtension
+      names, false, true, false);
+  if (res != S_OK)
+  {
+    if (destCurDirPrefix.Len() >= MAX_PATH)
+      MessageBox_Error_LangID(IDS_MESSAGE_UNSUPPORTED_OPERATION_FOR_LONG_PATH_FOLDER);
+  }
+  // KillSelection();
+}
+
+// function from ContextMenu.cpp
+UString GetSubFolderNameForExtract(const UString &arcPath);
+
+static UString GetSubFolderNameForExtract2(const UString &arcPath)
+{
+  int slashPos = arcPath.ReverseFind_PathSepar();
+  UString s;
+  UString name = arcPath;
+  if (slashPos >= 0)
+  {
+    s = arcPath.Left((unsigned)(slashPos + 1));
+    name = arcPath.Ptr((unsigned)(slashPos + 1));
+  }
+  s += GetSubFolderNameForExtract(name);
+  return s;
+}
+
+void CPanel::GetFilePaths(const CRecordVector<UInt32> &indices, UStringVector &paths, bool allowFolders)
+{
+  const UString prefix = GetFsPath();
+  FOR_VECTOR (i, indices)
+  {
+    int index = indices[i];
+    if (!allowFolders && IsItem_Folder(index))
+    {
+      paths.Clear();
+      break;
+    }
+    paths.Add(prefix + GetItemRelPath2(index));
+  }
+  if (paths.Size() == 0)
+  {
+    MessageBox_Error_LangID(IDS_SELECT_FILES);
+    return;
+  }
+}
+
+void CPanel::ExtractArchives()
+{
+  if (_parentFolders.Size() > 0)
+  {
+    _panelCallback->OnCopy(false, false);
+    return;
+  }
+  CRecordVector<UInt32> indices;
+  GetOperatedItemIndices(indices);
+  UStringVector paths;
+  GetFilePaths(indices, paths);
+  if (paths.IsEmpty())
+    return;
+  
+  UString outFolder = GetFsPath();
+  if (indices.Size() == 1)
+    outFolder += GetSubFolderNameForExtract2(GetItemRelPath(indices[0]));
+  else
+    outFolder += '*';
+  outFolder.Add_PathSepar();
+  
+  ::ExtractArchives(paths, outFolder
+      , true // showDialog
+      , false // elimDup
+      );
+}
+
+/*
+static void AddValuePair(UINT resourceID, UInt64 value, UString &s)
+{
+  AddLangString(s, resourceID);
+  char sz[32];
+  s += ": ";
+  ConvertUInt64ToString(value, sz);
+  s += sz;
+  s.Add_LF();
+}
+
+// now we don't need CThreadTest, since now we call CopyTo for "test command
+
+class CThreadTest: public CProgressThreadVirt
+{
+  HRESULT ProcessVirt();
+public:
+  CRecordVector<UInt32> Indices;
+  CExtractCallbackImp *ExtractCallbackSpec;
+  CMyComPtr<IFolderArchiveExtractCallback> ExtractCallback;
+  CMyComPtr<IArchiveFolder> ArchiveFolder;
+};
+
+HRESULT CThreadTest::ProcessVirt()
+{
+  RINOK(ArchiveFolder->Extract(&Indices[0], Indices.Size(),
+      true, // includeAltStreams
+      false, // replaceAltStreamColon
+      NExtract::NPathMode::kFullPathnames,
+      NExtract::NOverwriteMode::kAskBefore,
+      NULL, // path
+      BoolToInt(true), // testMode
+      ExtractCallback));
+  if (ExtractCallbackSpec->IsOK())
+  {
+    UString s;
+    AddValuePair(IDS_PROP_FOLDERS, ExtractCallbackSpec->NumFolders, s);
+    AddValuePair(IDS_PROP_FILES, ExtractCallbackSpec->NumFiles, s);
+    // AddValuePair(IDS_PROP_SIZE, ExtractCallbackSpec->UnpackSize, s);
+    // AddSizePair(IDS_COMPRESSED_COLON, Stat.PackSize, s);
+    s.Add_LF();
+    AddLangString(s, IDS_MESSAGE_NO_ERRORS);
+    FinalMessage.OkMessage.Message = s;
+  }
+  return S_OK;
+}
+
+static void AddSizePair(UInt32 langID, UInt64 value, UString &s)
+{
+  char sz[32];
+  AddLangString(s, langID);
+  s += L' ';
+  ConvertUInt64ToString(value, sz);
+  s += sz;
+  ConvertUInt64ToString(value >> 20, sz);
+  s += " (";
+  s += sz;
+  s += " MB)";
+  s.Add_LF();
+}
+*/
+
+void CPanel::TestArchives()
+{
+  CRecordVector<UInt32> indices;
+  GetOperatedIndicesSmart(indices);
+  CMyComPtr<IArchiveFolder> archiveFolder;
+  _folder.QueryInterface(IID_IArchiveFolder, &archiveFolder);
+  if (archiveFolder)
+  {
+    CCopyToOptions options;
+    options.streamMode = true;
+    options.showErrorMessages = true;
+    options.testMode = true;
+
+    UStringVector messages;
+    HRESULT res = CopyTo(options, indices, &messages);
+    if (res != S_OK)
+    {
+      if (res != E_ABORT)
+        MessageBox_Error_HRESULT(res);
+    }
+    return;
+
+    /*
+    {
+    CThreadTest extracter;
+
+    extracter.ArchiveFolder = archiveFolder;
+    extracter.ExtractCallbackSpec = new CExtractCallbackImp;
+    extracter.ExtractCallback = extracter.ExtractCallbackSpec;
+    extracter.ExtractCallbackSpec->ProgressDialog = &extracter.ProgressDialog;
+    if (!_parentFolders.IsEmpty())
+    {
+      const CFolderLink &fl = _parentFolders.Back();
+      extracter.ExtractCallbackSpec->PasswordIsDefined = fl.UsePassword;
+      extracter.ExtractCallbackSpec->Password = fl.Password;
+    }
+
+    if (indices.IsEmpty())
+      return;
+
+    extracter.Indices = indices;
+    
+    UString title = LangString(IDS_PROGRESS_TESTING);
+    
+    extracter.ProgressDialog.CompressingMode = false;
+    extracter.ProgressDialog.MainWindow = GetParent();
+    extracter.ProgressDialog.MainTitle = "7-Zip"; // LangString(IDS_APP_TITLE);
+    extracter.ProgressDialog.MainAddTitle = title + L' ';
+    
+    extracter.ExtractCallbackSpec->OverwriteMode = NExtract::NOverwriteMode::kAskBefore;
+    extracter.ExtractCallbackSpec->Init();
+    
+    if (extracter.Create(title, GetParent()) != S_OK)
+      return;
+    
+    }
+    RefreshTitleAlways();
+    return;
+    */
+  }
+
+  if (!IsFSFolder())
+  {
+    MessageBox_Error_UnsupportOperation();
+    return;
+  }
+  UStringVector paths;
+  GetFilePaths(indices, paths, true);
+  if (paths.IsEmpty())
+    return;
+  ::TestArchives(paths);
+}
diff --git a/CPP/7zip/UI/FileManager/Panel.h b/CPP/7zip/UI/FileManager/Panel.h
new file mode 100644
index 0000000..d1e4d24
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Panel.h
@@ -0,0 +1,926 @@
+// Panel.h
+
+#ifndef __PANEL_H
+#define __PANEL_H
+
+#include "../../../Common/MyWindows.h"
+
+#include <ShlObj.h>
+
+#include "../../../../C/Alloc.h"
+
+#include "../../../Common/Defs.h"
+#include "../../../Common/MyCom.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/Handle.h"
+#include "../../../Windows/PropVariantConv.h"
+#include "../../../Windows/Synchronization.h"
+
+#include "../../../Windows/Control/ComboBox.h"
+#include "../../../Windows/Control/Edit.h"
+#include "../../../Windows/Control/ListView.h"
+#include "../../../Windows/Control/ReBar.h"
+#include "../../../Windows/Control/Static.h"
+#include "../../../Windows/Control/StatusBar.h"
+#include "../../../Windows/Control/ToolBar.h"
+#include "../../../Windows/Control/Window2.h"
+
+#include "../../Archive/IArchive.h"
+
+#include "ExtractCallback.h"
+
+#include "AppState.h"
+#include "IFolder.h"
+#include "MyCom2.h"
+#include "ProgressDialog2.h"
+#include "SysIconUtils.h"
+
+#ifdef UNDER_CE
+#define NON_CE_VAR(_v_)
+#else
+#define NON_CE_VAR(_v_) _v_
+#endif
+
+const int kParentFolderID = 100;
+
+const int kParentIndex = -1;
+const UInt32 kParentIndex_UInt32 = (UInt32)(Int32)kParentIndex;
+
+#if !defined(_WIN32) || defined(UNDER_CE)
+#define ROOT_FS_FOLDER L"\\"
+#else
+#define ROOT_FS_FOLDER L"C:\\"
+#endif
+
+struct CPanelCallback
+{
+  virtual void OnTab() = 0;
+  virtual void SetFocusToPath(unsigned index) = 0;
+  virtual void OnCopy(bool move, bool copyToSame) = 0;
+  virtual void OnSetSameFolder() = 0;
+  virtual void OnSetSubFolder() = 0;
+  virtual void PanelWasFocused() = 0;
+  virtual void DragBegin() = 0;
+  virtual void DragEnd() = 0;
+  virtual void RefreshTitle(bool always) = 0;
+};
+
+void PanelCopyItems();
+
+
+struct CPropColumn
+{
+  int Order;
+  PROPID ID;
+  VARTYPE Type;
+  bool IsVisible;
+  bool IsRawProp;
+  UInt32 Width;
+  UString Name;
+
+  bool IsEqualTo(const CPropColumn &a) const
+  {
+    return Order == a.Order
+        && ID == a.ID
+        && Type == a.Type
+        && IsVisible == a.IsVisible
+        && IsRawProp == a.IsRawProp
+        && Width == a.Width
+        && Name == a.Name;
+  }
+
+  int Compare(const CPropColumn &a) const { return MyCompare(Order, a.Order); }
+
+  int Compare_NameFirst(const CPropColumn &a) const
+  {
+    if (ID == kpidName)
+    {
+      if (a.ID != kpidName)
+        return -1;
+    }
+    else if (a.ID == kpidName)
+      return 1;
+    return MyCompare(Order, a.Order);
+  }
+};
+
+
+class CPropColumns: public CObjectVector<CPropColumn>
+{
+public:
+  int FindItem_for_PropID(PROPID id) const
+  {
+    FOR_VECTOR (i, (*this))
+      if ((*this)[i].ID == id)
+        return i;
+    return -1;
+  }
+
+  bool IsEqualTo(const CPropColumns &props) const
+  {
+    if (Size() != props.Size())
+      return false;
+    FOR_VECTOR (i, (*this))
+      if (!(*this)[i].IsEqualTo(props[i]))
+        return false;
+    return true;
+  }
+};
+
+
+struct CTempFileInfo
+{
+  UInt32 FileIndex;  // index of file in folder
+  UString RelPath;   // Relative path of file from Folder
+  FString FolderPath;
+  FString FilePath;
+  NWindows::NFile::NFind::CFileInfo FileInfo;
+  bool NeedDelete;
+
+  CTempFileInfo(): FileIndex((UInt32)(Int32)-1), NeedDelete(false) {}
+  void DeleteDirAndFile() const
+  {
+    if (NeedDelete)
+    {
+      NWindows::NFile::NDir::DeleteFileAlways(FilePath);
+      NWindows::NFile::NDir::RemoveDir(FolderPath);
+    }
+  }
+  bool WasChanged(const NWindows::NFile::NFind::CFileInfo &newFileInfo) const
+  {
+    return newFileInfo.Size != FileInfo.Size ||
+        CompareFileTime(&newFileInfo.MTime, &FileInfo.MTime) != 0;
+  }
+};
+
+struct CFolderLink: public CTempFileInfo
+{
+  NWindows::NDLL::CLibrary Library;
+  CMyComPtr<IFolderFolder> ParentFolder; // can be NULL, if parent is FS folder (in _parentFolders[0])
+  UString ParentFolderPath; // including tail slash (doesn't include paths parts of parent in next level)
+  bool UsePassword;
+  UString Password;
+  bool IsVirtual;
+
+  UString VirtualPath; // without tail slash
+  CFolderLink(): UsePassword(false), IsVirtual(false) {}
+
+  bool WasChanged(const NWindows::NFile::NFind::CFileInfo &newFileInfo) const
+  {
+    return IsVirtual || CTempFileInfo::WasChanged(newFileInfo);
+  }
+
+};
+
+enum MyMessages
+{
+  // we can use WM_USER, since we have defined new window class.
+  // so we don't need WM_APP.
+  kShiftSelectMessage = WM_USER + 1,
+  kReLoadMessage,
+  kSetFocusToListView,
+  kOpenItemChanged,
+  kRefresh_StatusBar
+  #ifdef UNDER_CE
+  , kRefresh_HeaderComboBox
+  #endif
+};
+
+UString GetFolderPath(IFolderFolder *folder);
+
+class CPanel;
+
+class CMyListView: public NWindows::NControl::CListView2
+{
+public:
+  CPanel *_panel;
+  LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
+};
+
+/*
+class CMyComboBox: public NWindows::NControl::CComboBoxEx
+{
+public:
+  WNDPROC _origWindowProc;
+  CPanel *_panel;
+  LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
+};
+*/
+class CMyComboBoxEdit: public NWindows::NControl::CEdit
+{
+public:
+  WNDPROC _origWindowProc;
+  CPanel *_panel;
+  LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
+};
+
+struct CSelectedState
+{
+  int FocusedItem;
+  bool SelectFocused;
+  bool FocusedName_Defined;
+  UString FocusedName;
+  UStringVector SelectedNames;
+  
+  CSelectedState(): FocusedItem(-1), SelectFocused(true), FocusedName_Defined(false) {}
+};
+
+#ifdef UNDER_CE
+#define MY_NMLISTVIEW_NMITEMACTIVATE NMLISTVIEW
+#else
+#define MY_NMLISTVIEW_NMITEMACTIVATE NMITEMACTIVATE
+#endif
+
+struct CCopyToOptions
+{
+  bool streamMode;
+  bool moveMode;
+  bool testMode;
+  bool includeAltStreams;
+  bool replaceAltStreamChars;
+  bool showErrorMessages;
+
+  UString folder;
+
+  UStringVector hashMethods;
+
+  CVirtFileSystem *VirtFileSystemSpec;
+  ISequentialOutStream *VirtFileSystem;
+  
+  CCopyToOptions():
+      streamMode(false),
+      moveMode(false),
+      testMode(false),
+      includeAltStreams(true),
+      replaceAltStreamChars(false),
+      showErrorMessages(false),
+      VirtFileSystemSpec(NULL),
+      VirtFileSystem(NULL)
+      {}
+};
+  
+
+
+struct COpenResult
+{
+  // bool needOpenArc;
+  // out:
+  bool ArchiveIsOpened;
+  bool Encrypted;
+  UString ErrorMessage;
+
+  COpenResult():
+      // needOpenArc(false),
+      ArchiveIsOpened(false), Encrypted(false) {}
+};
+
+
+
+
+class CPanel: public NWindows::NControl::CWindow2
+{
+  CExtToIconMap _extToIconMap;
+  UINT _baseID;
+  int _comboBoxID;
+  UINT _statusBarID;
+
+  CAppState *_appState;
+
+  bool OnCommand(int code, int itemID, LPARAM lParam, LRESULT &result);
+  LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
+  virtual bool OnCreate(CREATESTRUCT *createStruct);
+  virtual bool OnSize(WPARAM wParam, int xSize, int ySize);
+  virtual void OnDestroy();
+  virtual bool OnNotify(UINT controlID, LPNMHDR lParam, LRESULT &result);
+
+  void AddComboBoxItem(const UString &name, int iconIndex, int indent, bool addToList);
+
+  bool OnComboBoxCommand(UINT code, LPARAM param, LRESULT &result);
+  
+  #ifndef UNDER_CE
+  
+  LRESULT OnNotifyComboBoxEnter(const UString &s);
+  bool OnNotifyComboBoxEndEdit(PNMCBEENDEDITW info, LRESULT &result);
+  #ifndef _UNICODE
+  bool OnNotifyComboBoxEndEdit(PNMCBEENDEDIT info, LRESULT &result);
+  #endif
+
+  #endif
+
+  bool OnNotifyReBar(LPNMHDR lParam, LRESULT &result);
+  bool OnNotifyComboBox(LPNMHDR lParam, LRESULT &result);
+  void OnItemChanged(NMLISTVIEW *item);
+  void OnNotifyActivateItems();
+  bool OnNotifyList(LPNMHDR lParam, LRESULT &result);
+  void OnDrag(LPNMLISTVIEW nmListView);
+  bool OnKeyDown(LPNMLVKEYDOWN keyDownInfo, LRESULT &result);
+  BOOL OnBeginLabelEdit(LV_DISPINFOW * lpnmh);
+  BOOL OnEndLabelEdit(LV_DISPINFOW * lpnmh);
+  void OnColumnClick(LPNMLISTVIEW info);
+  bool OnCustomDraw(LPNMLVCUSTOMDRAW lplvcd, LRESULT &result);
+
+
+public:
+  HWND _mainWindow;
+  CPanelCallback *_panelCallback;
+
+  void SysIconsWereChanged() { _extToIconMap.Clear(); }
+
+  void DeleteItems(bool toRecycleBin);
+  void CreateFolder();
+  void CreateFile();
+  bool CorrectFsPath(const UString &path, UString &result);
+  // bool IsPathForPlugin(const UString &path);
+
+private:
+
+  void ChangeWindowSize(int xSize, int ySize);
+ 
+  HRESULT InitColumns();
+  void DeleteColumn(unsigned index);
+  void AddColumn(const CPropColumn &prop);
+
+  void SetFocusedSelectedItem(int index, bool select);
+  
+  void OnShiftSelectMessage();
+  void OnArrowWithShift();
+
+  void OnInsert();
+  // void OnUpWithShift();
+  // void OnDownWithShift();
+public:
+  void UpdateSelection();
+  void SelectSpec(bool selectMode);
+  void SelectByType(bool selectMode);
+  void SelectAll(bool selectMode);
+  void InvertSelection();
+private:
+
+  // UString GetFileType(UInt32 index);
+  LRESULT SetItemText(LVITEMW &item);
+
+  // CRecordVector<PROPID> m_ColumnsPropIDs;
+
+public:
+  NWindows::NControl::CReBar _headerReBar;
+  NWindows::NControl::CToolBar _headerToolBar;
+  NWindows::NControl::
+    #ifdef UNDER_CE
+    CComboBox
+    #else
+    CComboBoxEx
+    #endif
+    _headerComboBox;
+  UStringVector ComboBoxPaths;
+  // CMyComboBox _headerComboBox;
+  CMyComboBoxEdit _comboBoxEdit;
+  CMyListView _listView;
+  bool _thereAre_ListView_Items;
+  NWindows::NControl::CStatusBar _statusBar;
+  bool _lastFocusedIsList;
+  // NWindows::NControl::CStatusBar _statusBar2;
+
+  DWORD _exStyle;
+  bool _showDots;
+  bool _showRealFileIcons;
+  // bool _virtualMode;
+  // CUIntVector _realIndices;
+  bool _enableItemChangeNotify;
+  bool _mySelectMode;
+
+  int _timestampLevel;
+
+
+  void RedrawListItems()
+  {
+    _listView.RedrawAllItems();
+  }
+
+
+  CBoolVector _selectedStatusVector;
+
+  CSelectedState _selectedState;
+  bool _thereAreDeletedItems;
+  bool _markDeletedItems;
+
+  bool PanelCreated;
+
+  void DeleteListItems()
+  {
+    if (_thereAre_ListView_Items)
+    {
+      bool b = _enableItemChangeNotify;
+      _enableItemChangeNotify = false;
+      _listView.DeleteAllItems();
+      _thereAre_ListView_Items = false;
+      _enableItemChangeNotify = b;
+    }
+  }
+
+  HWND GetParent() const;
+
+  UInt32 GetRealIndex(const LVITEMW &item) const
+  {
+    /*
+    if (_virtualMode)
+      return _realIndices[item.iItem];
+    */
+    return (UInt32)item.lParam;
+  }
+  
+  int GetRealItemIndex(int indexInListView) const
+  {
+    /*
+    if (_virtualMode)
+      return indexInListView;
+    */
+    LPARAM param;
+    if (!_listView.GetItemParam(indexInListView, param))
+      throw 1;
+    return (int)param;
+  }
+
+  UInt32 _ListViewMode;
+  int _xSize;
+
+  bool _flatMode;
+  bool _flatModeForDisk;
+  bool _flatModeForArc;
+
+  // bool _showNtfsStrems_Mode;
+  // bool _showNtfsStrems_ModeForDisk;
+  // bool _showNtfsStrems_ModeForArc;
+
+  bool _dontShowMode;
+
+
+  UString _currentFolderPrefix;
+  
+  CObjectVector<CFolderLink> _parentFolders;
+  NWindows::NDLL::CLibrary _library;
+  
+  CMyComPtr<IFolderFolder> _folder;
+  CMyComPtr<IFolderCompare> _folderCompare;
+  CMyComPtr<IFolderGetItemName> _folderGetItemName;
+  CMyComPtr<IArchiveGetRawProps> _folderRawProps;
+  CMyComPtr<IFolderAltStreams> _folderAltStreams;
+  CMyComPtr<IFolderOperations> _folderOperations;
+
+  void ReleaseFolder();
+  void SetNewFolder(IFolderFolder *newFolder);
+
+  // CMyComPtr<IFolderGetSystemIconIndex> _folderGetSystemIconIndex;
+
+  UStringVector _fastFolders;
+
+  void GetSelectedNames(UStringVector &selectedNames);
+  void SaveSelectedState(CSelectedState &s);
+  HRESULT RefreshListCtrl(const CSelectedState &s);
+  HRESULT RefreshListCtrl_SaveFocused();
+
+  bool GetItem_BoolProp(UInt32 itemIndex, PROPID propID) const;
+  bool IsItem_Deleted(int itemIndex) const;
+  bool IsItem_Folder(int itemIndex) const;
+  bool IsItem_AltStream(int itemIndex) const;
+
+  UString GetItemName(int itemIndex) const;
+  UString GetItemName_for_Copy(int itemIndex) const;
+  void GetItemName(int itemIndex, UString &s) const;
+  UString GetItemPrefix(int itemIndex) const;
+  UString GetItemRelPath(int itemIndex) const;
+  UString GetItemRelPath2(int itemIndex) const;
+  UString GetItemFullPath(int itemIndex) const;
+  UInt64 GetItem_UInt64Prop(int itemIndex, PROPID propID) const;
+  UInt64 GetItemSize(int itemIndex) const;
+
+  ////////////////////////
+  // PanelFolderChange.cpp
+
+  void SetToRootFolder();
+  HRESULT BindToPath(const UString &fullPath, const UString &arcFormat, COpenResult &openRes); // can be prefix
+  HRESULT BindToPathAndRefresh(const UString &path);
+  void OpenDrivesFolder();
+  
+  void SetBookmark(unsigned index);
+  void OpenBookmark(unsigned index);
+  
+  void LoadFullPath();
+  void LoadFullPathAndShow();
+  void FoldersHistory();
+  void OpenParentFolder();
+  void CloseOneLevel();
+  void CloseOpenFolders();
+  void OpenRootFolder();
+
+  UString GetParentDirPrefix() const;
+
+  HRESULT Create(HWND mainWindow, HWND parentWindow,
+      UINT id,
+      const UString &currentFolderPrefix,
+      const UString &arcFormat,
+      CPanelCallback *panelCallback,
+      CAppState *appState,
+      bool needOpenArc,
+      COpenResult &openRes);
+
+  void SetFocusToList();
+  void SetFocusToLastRememberedItem();
+
+
+  void SaveListViewInfo();
+
+  CPanel() :
+      _thereAre_ListView_Items(false),
+      _exStyle(0),
+      _showDots(false),
+      _showRealFileIcons(false),
+      // _virtualMode(flase),
+      _enableItemChangeNotify(true),
+      _mySelectMode(false),
+      _timestampLevel(kTimestampPrintLevel_MIN),
+
+      _thereAreDeletedItems(false),
+      _markDeletedItems(true),
+      PanelCreated(false),
+
+      _ListViewMode(3),
+      _xSize(300),
+
+      _flatMode(false),
+      _flatModeForDisk(false),
+      _flatModeForArc(false),
+
+      // _showNtfsStrems_Mode(false),
+      // _showNtfsStrems_ModeForDisk(false),
+      // _showNtfsStrems_ModeForArc(false),
+
+      _dontShowMode(false),
+
+      _needSaveInfo(false),
+      _startGroupSelect(0),
+      _selectionIsDefined(false)
+  {}
+
+  void SetExtendedStyle()
+  {
+    if (_listView != 0)
+      _listView.SetExtendedListViewStyle(_exStyle);
+  }
+
+
+  bool _needSaveInfo;
+  UString _typeIDString;
+  CListViewInfo _listViewInfo;
+  
+  CPropColumns _columns;
+  CPropColumns _visibleColumns;
+  
+  PROPID _sortID;
+  // int _sortIndex;
+  bool _ascending;
+  Int32 _isRawSortProp;
+
+  void SetSortRawStatus();
+
+  void Release();
+  ~CPanel();
+  void OnLeftClick(MY_NMLISTVIEW_NMITEMACTIVATE *itemActivate);
+  bool OnRightClick(MY_NMLISTVIEW_NMITEMACTIVATE *itemActivate, LRESULT &result);
+  void ShowColumnsContextMenu(int x, int y);
+
+  void OnTimer();
+  void OnReload();
+  bool OnContextMenu(HANDLE windowHandle, int xPos, int yPos);
+
+  CMyComPtr<IContextMenu> _sevenZipContextMenu;
+  CMyComPtr<IContextMenu> _systemContextMenu;
+  HRESULT CreateShellContextMenu(
+      const CRecordVector<UInt32> &operatedIndices,
+      CMyComPtr<IContextMenu> &systemContextMenu);
+  void CreateSystemMenu(HMENU menu,
+      const CRecordVector<UInt32> &operatedIndices,
+      CMyComPtr<IContextMenu> &systemContextMenu);
+  void CreateSevenZipMenu(HMENU menu,
+      const CRecordVector<UInt32> &operatedIndices,
+      CMyComPtr<IContextMenu> &sevenZipContextMenu);
+  void CreateFileMenu(HMENU menu,
+      CMyComPtr<IContextMenu> &sevenZipContextMenu,
+      CMyComPtr<IContextMenu> &systemContextMenu,
+      bool programMenu);
+  void CreateFileMenu(HMENU menu);
+  bool InvokePluginCommand(unsigned id);
+  bool InvokePluginCommand(unsigned id, IContextMenu *sevenZipContextMenu,
+      IContextMenu *systemContextMenu);
+
+  void InvokeSystemCommand(const char *command);
+  void Properties();
+  void EditCut();
+  void EditCopy();
+  void EditPaste();
+
+  int _startGroupSelect;
+
+  bool _selectionIsDefined;
+  bool _selectMark;
+  int _prevFocusedItem;
+
+ 
+  // void SortItems(int index);
+  void SortItemsWithPropID(PROPID propID);
+
+  void GetSelectedItemsIndices(CRecordVector<UInt32> &indices) const;
+  void GetOperatedItemIndices(CRecordVector<UInt32> &indices) const;
+  void GetAllItemIndices(CRecordVector<UInt32> &indices) const;
+  void GetOperatedIndicesSmart(CRecordVector<UInt32> &indices) const;
+  // void GetOperatedListViewIndices(CRecordVector<UInt32> &indices) const;
+  void KillSelection();
+
+  UString GetFolderTypeID() const;
+  
+  bool IsFolderTypeEqTo(const char *s) const;
+  bool IsRootFolder() const;
+  bool IsFSFolder() const;
+  bool IsFSDrivesFolder() const;
+  bool IsAltStreamsFolder() const;
+  bool IsArcFolder() const;
+  bool IsHashFolder() const;
+  
+  /*
+    c:\Dir
+    Computer\
+    \\?\
+    \\.\
+  */
+  bool Is_IO_FS_Folder() const
+  {
+    return IsFSFolder() || IsFSDrivesFolder() || IsAltStreamsFolder();
+  }
+
+  bool Is_Slow_Icon_Folder() const
+  {
+    return IsFSFolder() || IsAltStreamsFolder();
+  }
+
+  // bool IsFsOrDrivesFolder() const { return IsFSFolder() || IsFSDrivesFolder(); }
+  bool IsDeviceDrivesPrefix() const { return _currentFolderPrefix == L"\\\\.\\"; }
+  bool IsSuperDrivesPrefix() const { return _currentFolderPrefix == L"\\\\?\\"; }
+  
+  /*
+    c:\Dir
+    Computer\
+    \\?\
+  */
+  bool IsFsOrPureDrivesFolder() const { return IsFSFolder() || (IsFSDrivesFolder() && !IsDeviceDrivesPrefix()); }
+
+  /*
+    c:\Dir
+    Computer\
+    \\?\
+    \\SERVER\
+  */
+  bool IsFolder_with_FsItems() const
+  {
+    if (IsFsOrPureDrivesFolder())
+      return true;
+    #if defined(_WIN32) && !defined(UNDER_CE)
+    FString prefix = us2fs(GetFsPath());
+    return (prefix.Len() == NWindows::NFile::NName::GetNetworkServerPrefixSize(prefix));
+    #else
+    return false;
+    #endif
+  }
+
+  UString GetFsPath() const;
+  UString GetDriveOrNetworkPrefix() const;
+
+  bool DoesItSupportOperations() const { return _folderOperations != NULL; }
+  bool IsThereReadOnlyFolder() const;
+  bool CheckBeforeUpdate(UINT resourceID);
+
+  bool _processTimer;
+  bool _processNotify;
+  bool _processStatusBar;
+
+  class CDisableTimerProcessing
+  {
+    CLASS_NO_COPY(CDisableTimerProcessing);
+
+    bool _processTimer;
+
+    CPanel &_panel;
+    
+    public:
+
+    CDisableTimerProcessing(CPanel &panel): _panel(panel) { Disable(); }
+    ~CDisableTimerProcessing() { Restore(); }
+    void Disable()
+    {
+      _processTimer = _panel._processTimer;
+      _panel._processTimer = false;
+    }
+    void Restore()
+    {
+      _panel._processTimer = _processTimer;
+    }
+  };
+
+  class CDisableNotify
+  {
+    CLASS_NO_COPY(CDisableNotify);
+
+    bool _processNotify;
+    bool _processStatusBar;
+
+    CPanel &_panel;
+
+    public:
+
+    CDisableNotify(CPanel &panel): _panel(panel) { Disable(); }
+    ~CDisableNotify() { Restore(); }
+    void Disable()
+    {
+      _processNotify = _panel._processNotify;
+      _processStatusBar = _panel._processStatusBar;
+      _panel._processNotify = false;
+      _panel._processStatusBar = false;
+    }
+    void SetMemMode_Enable()
+    {
+      _processNotify = true;
+      _processStatusBar = true;
+    }
+    void Restore()
+    {
+      _panel._processNotify = _processNotify;
+      _panel._processStatusBar = _processStatusBar;
+    }
+  };
+
+  void InvalidateList() { _listView.InvalidateRect(NULL, true); }
+
+  HRESULT RefreshListCtrl();
+
+  
+  // void MessageBox_Info(LPCWSTR message, LPCWSTR caption) const;
+  // void MessageBox_Warning(LPCWSTR message) const;
+  void MessageBox_Error_Caption(LPCWSTR message, LPCWSTR caption) const;
+  void MessageBox_Error(LPCWSTR message) const;
+  void MessageBox_Error_HRESULT_Caption(HRESULT errorCode, LPCWSTR caption) const;
+  void MessageBox_Error_HRESULT(HRESULT errorCode) const;
+  void MessageBox_Error_2Lines_Message_HRESULT(LPCWSTR message, HRESULT errorCode) const;
+  void MessageBox_LastError(LPCWSTR caption) const;
+  void MessageBox_LastError() const;
+  void MessageBox_Error_LangID(UINT resourceID) const;
+  void MessageBox_Error_UnsupportOperation() const;
+  // void MessageBoxErrorForUpdate(HRESULT errorCode, UINT resourceID);
+
+
+  void OpenAltStreams();
+
+  void OpenFocusedItemAsInternal(const wchar_t *type = NULL);
+  void OpenSelectedItems(bool internal);
+
+  void OpenFolderExternal(int index);
+
+  void OpenFolder(int index);
+  HRESULT OpenParentArchiveFolder();
+  
+  HRESULT OpenAsArc(IInStream *inStream,
+      const CTempFileInfo &tempFileInfo,
+      const UString &virtualFilePath,
+      const UString &arcFormat,
+      COpenResult &openRes);
+
+  HRESULT OpenAsArc_Msg(IInStream *inStream,
+      const CTempFileInfo &tempFileInfo,
+      const UString &virtualFilePath,
+      const UString &arcFormat
+      // , bool showErrorMessage
+      );
+  
+  HRESULT OpenAsArc_Name(const UString &relPath, const UString &arcFormat
+      // , bool showErrorMessage
+      );
+  HRESULT OpenAsArc_Index(int index, const wchar_t *type /* = NULL */
+      // , bool showErrorMessage
+      );
+  
+  void OpenItemInArchive(int index, bool tryInternal, bool tryExternal,
+      bool editMode, bool useEditor, const wchar_t *type = NULL);
+  
+  HRESULT OnOpenItemChanged(UInt32 index, const wchar_t *fullFilePath, bool usePassword, const UString &password);
+  LRESULT OnOpenItemChanged(LPARAM lParam);
+
+  bool IsVirus_Message(const UString &name);
+  void OpenItem(int index, bool tryInternal, bool tryExternal, const wchar_t *type = NULL);
+  void EditItem(bool useEditor);
+  void EditItem(int index, bool useEditor);
+
+  void RenameFile();
+  void ChangeComment();
+
+  void SetListViewMode(UInt32 index);
+  UInt32 GetListViewMode() const { return _ListViewMode; }
+  PROPID GetSortID() const { return _sortID; }
+
+  void ChangeFlatMode();
+  void Change_ShowNtfsStrems_Mode();
+  bool GetFlatMode() const { return _flatMode; }
+  // bool Get_ShowNtfsStrems_Mode() const { return _showNtfsStrems_Mode; }
+
+  bool AutoRefresh_Mode;
+  void Set_AutoRefresh_Mode(bool mode)
+  {
+    AutoRefresh_Mode = mode;
+  }
+  
+  void Post_Refresh_StatusBar();
+  void Refresh_StatusBar();
+
+  void AddToArchive();
+
+  void GetFilePaths(const CRecordVector<UInt32> &indices, UStringVector &paths, bool allowFolders = false);
+  void ExtractArchives();
+  void TestArchives();
+
+  HRESULT CopyTo(CCopyToOptions &options,
+      const CRecordVector<UInt32> &indices,
+      UStringVector *messages,
+      bool &usePassword, UString &password);
+
+  HRESULT CopyTo(CCopyToOptions &options, const CRecordVector<UInt32> &indices, UStringVector *messages)
+  {
+    bool usePassword = false;
+    UString password;
+    if (_parentFolders.Size() > 0)
+    {
+      const CFolderLink &fl = _parentFolders.Back();
+      usePassword = fl.UsePassword;
+      password = fl.Password;
+    }
+    return CopyTo(options, indices, messages, usePassword, password);
+  }
+
+  HRESULT CopyFrom(bool moveMode, const UString &folderPrefix, const UStringVector &filePaths,
+      bool showErrorMessages, UStringVector *messages);
+
+  void CopyFromNoAsk(const UStringVector &filePaths);
+  void CopyFromAsk(const UStringVector &filePaths);
+
+  // empty folderPath means create new Archive to path of first fileName.
+  void DropObject(IDataObject * dataObject, const UString &folderPath);
+
+  // empty folderPath means create new Archive to path of first fileName.
+  void CompressDropFiles(const UStringVector &fileNames, const UString &folderPath);
+
+  void RefreshTitle(bool always = false) { _panelCallback->RefreshTitle(always);  }
+  void RefreshTitleAlways() { RefreshTitle(true);  }
+
+  UString GetItemsInfoString(const CRecordVector<UInt32> &indices);
+};
+
+class CMyBuffer
+{
+  void *_data;
+public:
+  CMyBuffer(): _data(0) {}
+  operator void *() { return _data; }
+  bool Allocate(size_t size)
+  {
+    if (_data != 0)
+      return false;
+    _data = ::MidAlloc(size);
+    return _data != 0;
+  }
+  ~CMyBuffer() { ::MidFree(_data); }
+};
+
+class CExitEventLauncher
+{
+public:
+  NWindows::NSynchronization::CManualResetEvent _exitEvent;
+  bool _needExit;
+  CRecordVector< ::CThread > _threads;
+  unsigned _numActiveThreads;
+    
+  CExitEventLauncher()
+  {
+    _needExit = false;
+    if (_exitEvent.Create(false) != S_OK)
+      throw 9387173;
+    _needExit = true;
+    _numActiveThreads = 0;
+  };
+
+  ~CExitEventLauncher() { Exit(true); }
+
+  void Exit(bool hardExit);
+};
+
+extern CExitEventLauncher g_ExitEventLauncher;
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/PanelCopy.cpp b/CPP/7zip/UI/FileManager/PanelCopy.cpp
new file mode 100644
index 0000000..7e1937c
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelCopy.cpp
@@ -0,0 +1,410 @@
+/// PanelCopy.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyException.h"
+
+#include "../GUI/HashGUI.h"
+
+#include "ExtractCallback.h"
+#include "LangUtils.h"
+#include "Panel.h"
+#include "resource.h"
+#include "UpdateCallback100.h"
+
+using namespace NWindows;
+
+class CPanelCopyThread: public CProgressThreadVirt
+{
+  bool ResultsWereShown;
+  bool NeedShowRes;
+
+  HRESULT ProcessVirt();
+  virtual void ProcessWasFinished_GuiVirt();
+public:
+  const CCopyToOptions *options;
+  CMyComPtr<IFolderOperations> FolderOperations;
+  CRecordVector<UInt32> Indices;
+  CExtractCallbackImp *ExtractCallbackSpec;
+  CMyComPtr<IFolderOperationsExtractCallback> ExtractCallback;
+  
+  CHashBundle Hash;
+  // UString FirstFilePath;
+
+  // HRESULT Result2;
+
+  void ShowFinalResults(HWND hwnd);
+  
+  CPanelCopyThread():
+    ResultsWereShown(false),
+    NeedShowRes(false)
+    // , Result2(E_FAIL)
+    {}
+};
+
+void CPanelCopyThread::ShowFinalResults(HWND hwnd)
+{
+  if (NeedShowRes)
+  if (!ResultsWereShown)
+  {
+    ResultsWereShown = true;
+    ShowHashResults(Hash, hwnd);
+  }
+}
+  
+void CPanelCopyThread::ProcessWasFinished_GuiVirt()
+{
+  ShowFinalResults(*this);
+}
+
+HRESULT CPanelCopyThread::ProcessVirt()
+{
+  /*
+  CMyComPtr<IFolderSetReplaceAltStreamCharsMode> iReplace;
+  FolderOperations.QueryInterface(IID_IFolderSetReplaceAltStreamCharsMode, &iReplace);
+  if (iReplace)
+  {
+    RINOK(iReplace->SetReplaceAltStreamCharsMode(ReplaceAltStreamChars ? 1 : 0));
+  }
+  */
+
+  HRESULT result2;
+
+  if (options->testMode)
+  {
+    CMyComPtr<IArchiveFolder> archiveFolder;
+    FolderOperations.QueryInterface(IID_IArchiveFolder, &archiveFolder);
+    if (!archiveFolder)
+      return E_NOTIMPL;
+    CMyComPtr<IFolderArchiveExtractCallback> extractCallback2;
+    RINOK(ExtractCallback.QueryInterface(IID_IFolderArchiveExtractCallback, &extractCallback2));
+    NExtract::NPathMode::EEnum pathMode =
+        NExtract::NPathMode::kCurPaths;
+        // NExtract::NPathMode::kFullPathnames;
+    result2 = archiveFolder->Extract(&Indices.Front(), Indices.Size(),
+        BoolToInt(options->includeAltStreams),
+        BoolToInt(options->replaceAltStreamChars),
+        pathMode, NExtract::NOverwriteMode::kAsk,
+        options->folder, BoolToInt(true), extractCallback2);
+  }
+  else
+    result2 = FolderOperations->CopyTo(
+      BoolToInt(options->moveMode),
+      &Indices.Front(), Indices.Size(),
+      BoolToInt(options->includeAltStreams),
+      BoolToInt(options->replaceAltStreamChars),
+      options->folder, ExtractCallback);
+
+  if (result2 == S_OK && !ExtractCallbackSpec->ThereAreMessageErrors)
+  {
+    if (!options->hashMethods.IsEmpty())
+      NeedShowRes = true;
+    else if (options->testMode)
+    {
+      CProgressMessageBoxPair &pair = GetMessagePair(false); // GetMessagePair(ExtractCallbackSpec->Hash.NumErrors != 0);
+      AddHashBundleRes(pair.Message, Hash);
+    }
+  }
+
+  return result2;
+}
+
+
+/*
+#ifdef EXTERNAL_CODECS
+
+static void ThrowException_if_Error(HRESULT res)
+{
+  if (res != S_OK)
+    throw CSystemException(res);
+}
+
+#endif
+*/
+
+HRESULT CPanel::CopyTo(CCopyToOptions &options, const CRecordVector<UInt32> &indices,
+    UStringVector *messages,
+    bool &usePassword, UString &password)
+{
+  if (IsHashFolder())
+  {
+    if (!options.testMode)
+      return E_NOTIMPL;
+  }
+  
+  if (!_folderOperations)
+  {
+    UString errorMessage = LangString(IDS_OPERATION_IS_NOT_SUPPORTED);
+    if (options.showErrorMessages)
+      MessageBox_Error(errorMessage);
+    else if (messages)
+      messages->Add(errorMessage);
+    return E_FAIL;
+  }
+
+  HRESULT res = S_OK;
+
+  {
+  /*
+  #ifdef EXTERNAL_CODECS
+  CExternalCodecs g_ExternalCodecs;
+  #endif
+  */
+  /* extracter.Hash uses g_ExternalCodecs
+     extracter must be declared after g_ExternalCodecs for correct destructor order !!! */
+
+  CPanelCopyThread extracter;
+
+  extracter.ExtractCallbackSpec = new CExtractCallbackImp;
+  extracter.ExtractCallback = extracter.ExtractCallbackSpec;
+
+  extracter.options = &options;
+  extracter.ExtractCallbackSpec->ProgressDialog = &extracter;
+  extracter.CompressingMode = false;
+
+  extracter.ExtractCallbackSpec->StreamMode = options.streamMode;
+
+
+  if (indices.Size() == 1)
+  {
+    extracter.Hash.FirstFileName = GetItemRelPath(indices[0]);
+    extracter.Hash.MainName = extracter.Hash.FirstFileName;
+  }
+
+  if (options.VirtFileSystem)
+  {
+    extracter.ExtractCallbackSpec->VirtFileSystem = options.VirtFileSystem;
+    extracter.ExtractCallbackSpec->VirtFileSystemSpec = options.VirtFileSystemSpec;
+  }
+  extracter.ExtractCallbackSpec->ProcessAltStreams = options.includeAltStreams;
+
+  if (!options.hashMethods.IsEmpty())
+  {
+    /* this code is used when we call CRC calculation for files in side archive
+       But new code uses global codecs so we don't need to call LoadGlobalCodecs again */
+
+    /*
+    #ifdef EXTERNAL_CODECS
+    ThrowException_if_Error(LoadGlobalCodecs());
+    #endif
+    */
+
+    extracter.Hash.SetMethods(EXTERNAL_CODECS_VARS_G options.hashMethods);
+    extracter.ExtractCallbackSpec->SetHashMethods(&extracter.Hash);
+  }
+  else if (options.testMode)
+  {
+    extracter.ExtractCallbackSpec->SetHashCalc(&extracter.Hash);
+  }
+
+  // extracter.Hash.Init();
+
+  UString title;
+  {
+    UInt32 titleID = IDS_COPYING;
+    if (options.moveMode)
+      titleID = IDS_MOVING;
+    else if (!options.hashMethods.IsEmpty() && options.streamMode)
+    {
+      titleID = IDS_CHECKSUM_CALCULATING;
+      if (options.hashMethods.Size() == 1)
+      {
+        const UString &s = options.hashMethods[0];
+        if (s != L"*")
+          title = s;
+      }
+    }
+    else if (options.testMode)
+      titleID = IDS_PROGRESS_TESTING;
+
+    if (title.IsEmpty())
+      title = LangString(titleID);
+  }
+
+  UString progressWindowTitle ("7-Zip"); // LangString(IDS_APP_TITLE);
+  
+  extracter.MainWindow = GetParent();
+  extracter.MainTitle = progressWindowTitle;
+  extracter.MainAddTitle = title + L' ';
+    
+  extracter.ExtractCallbackSpec->OverwriteMode = NExtract::NOverwriteMode::kAsk;
+  extracter.ExtractCallbackSpec->Init();
+  extracter.Indices = indices;
+  extracter.FolderOperations = _folderOperations;
+
+  extracter.ExtractCallbackSpec->PasswordIsDefined = usePassword;
+  extracter.ExtractCallbackSpec->Password = password;
+  
+  RINOK(extracter.Create(title, GetParent()));
+  
+
+  if (messages)
+    *messages = extracter.Sync.Messages;
+
+  // res = extracter.Result2;
+  res = extracter.Result;
+
+  if (res == S_OK && extracter.ExtractCallbackSpec->IsOK())
+  {
+    usePassword = extracter.ExtractCallbackSpec->PasswordIsDefined;
+    password = extracter.ExtractCallbackSpec->Password;
+  }
+
+  extracter.ShowFinalResults(_window);
+
+  }
+  
+  RefreshTitleAlways();
+  return res;
+}
+
+
+struct CThreadUpdate
+{
+  CMyComPtr<IFolderOperations> FolderOperations;
+  UString FolderPrefix;
+  UStringVector FileNames;
+  CRecordVector<const wchar_t *> FileNamePointers;
+  CProgressDialog ProgressDialog;
+  CMyComPtr<IFolderArchiveUpdateCallback> UpdateCallback;
+  CUpdateCallback100Imp *UpdateCallbackSpec;
+  HRESULT Result;
+  bool MoveMode;
+  
+  void Process()
+  {
+    try
+    {
+      CProgressCloser closer(ProgressDialog);
+      Result = FolderOperations->CopyFrom(
+        MoveMode,
+        FolderPrefix,
+        &FileNamePointers.Front(),
+        FileNamePointers.Size(),
+        UpdateCallback);
+    }
+    catch(...) { Result = E_FAIL; }
+  }
+  static THREAD_FUNC_DECL MyThreadFunction(void *param)
+  {
+    ((CThreadUpdate *)param)->Process();
+    return 0;
+  }
+};
+
+
+HRESULT CPanel::CopyFrom(bool moveMode, const UString &folderPrefix, const UStringVector &filePaths,
+    bool showErrorMessages, UStringVector *messages)
+{
+  if (IsHashFolder())
+  {
+    if (moveMode)
+      return E_NOTIMPL;
+  }
+  // CDisableNotify disableNotify(*this);
+
+  HRESULT res;
+  if (!_folderOperations)
+    res = E_NOINTERFACE;
+  else
+  {
+  CThreadUpdate updater;
+  updater.MoveMode = moveMode;
+  updater.UpdateCallbackSpec = new CUpdateCallback100Imp;
+  updater.UpdateCallback = updater.UpdateCallbackSpec;
+  updater.UpdateCallbackSpec->Init();
+
+  updater.UpdateCallbackSpec->ProgressDialog = &updater.ProgressDialog;
+
+  UString title = LangString(IDS_COPYING);
+  UString progressWindowTitle ("7-Zip"); // LangString(IDS_APP_TITLE);
+
+  updater.ProgressDialog.MainWindow = GetParent();
+  updater.ProgressDialog.MainTitle = progressWindowTitle;
+  updater.ProgressDialog.MainAddTitle = title + L' ';
+  
+  {
+    if (!_parentFolders.IsEmpty())
+    {
+      const CFolderLink &fl = _parentFolders.Back();
+      updater.UpdateCallbackSpec->PasswordIsDefined = fl.UsePassword;
+      updater.UpdateCallbackSpec->Password = fl.Password;
+    }
+  }
+
+  updater.FolderOperations = _folderOperations;
+  updater.FolderPrefix = folderPrefix;
+  updater.FileNames.ClearAndReserve(filePaths.Size());
+  unsigned i;
+  for (i = 0; i < filePaths.Size(); i++)
+    updater.FileNames.AddInReserved(filePaths[i]);
+  updater.FileNamePointers.ClearAndReserve(updater.FileNames.Size());
+  for (i = 0; i < updater.FileNames.Size(); i++)
+    updater.FileNamePointers.AddInReserved(updater.FileNames[i]);
+
+  {
+    NWindows::CThread thread;
+    RINOK(thread.Create(CThreadUpdate::MyThreadFunction, &updater));
+    updater.ProgressDialog.Create(title, thread, GetParent());
+  }
+
+  if (messages)
+    *messages = updater.ProgressDialog.Sync.Messages;
+
+  res = updater.Result;
+  }
+
+  if (res == E_NOINTERFACE)
+  {
+    UString errorMessage = LangString(IDS_OPERATION_IS_NOT_SUPPORTED);
+    if (showErrorMessages)
+      MessageBox_Error(errorMessage);
+    else if (messages)
+      messages->Add(errorMessage);
+    return E_ABORT;
+  }
+
+  RefreshTitleAlways();
+  return res;
+}
+
+void CPanel::CopyFromNoAsk(const UStringVector &filePaths)
+{
+  CDisableTimerProcessing disableTimerProcessing(*this);
+
+  CSelectedState srcSelState;
+  SaveSelectedState(srcSelState);
+
+  CDisableNotify disableNotify(*this);
+
+  HRESULT result = CopyFrom(false, L"", filePaths, true, 0);
+
+  if (result != S_OK)
+  {
+    disableNotify.Restore();
+    // For Password:
+    SetFocusToList();
+    if (result != E_ABORT)
+      MessageBox_Error_HRESULT(result);
+    return;
+  }
+
+  RefreshListCtrl(srcSelState);
+
+  disableNotify.Restore();
+  SetFocusToList();
+}
+
+void CPanel::CopyFromAsk(const UStringVector &filePaths)
+{
+  UString title = LangString(IDS_CONFIRM_FILE_COPY);
+  UString message = LangString(IDS_WANT_TO_COPY_FILES);
+  message += "\n\'";
+  message += _currentFolderPrefix;
+  message += "\' ?";
+  int res = ::MessageBoxW(*(this), message, title, MB_YESNOCANCEL | MB_ICONQUESTION);
+  if (res != IDYES)
+    return;
+
+  CopyFromNoAsk(filePaths);
+}
diff --git a/CPP/7zip/UI/FileManager/PanelCrc.cpp b/CPP/7zip/UI/FileManager/PanelCrc.cpp
new file mode 100644
index 0000000..1d483ca
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelCrc.cpp
@@ -0,0 +1,421 @@
+// PanelCrc.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyException.h"
+
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/FileIO.h"
+#include "../../../Windows/FileName.h"
+
+#include "../Common/LoadCodecs.h"
+
+#include "../GUI/HashGUI.h"
+
+#include "App.h"
+#include "LangUtils.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+using namespace NFile;
+
+#ifdef EXTERNAL_CODECS
+extern CExternalCodecs g_ExternalCodecs;
+HRESULT LoadGlobalCodecs();
+#endif
+
+static const UInt32 kBufSize = (1 << 15);
+
+struct CDirEnumerator
+{
+  bool EnterToDirs;
+  FString BasePrefix;
+  FString BasePrefix_for_Open;
+  FStringVector FilePaths;
+
+  CObjectVector<NFind::CEnumerator> Enumerators;
+  FStringVector Prefixes;
+  unsigned Index;
+
+  CDirEnumerator(): EnterToDirs(false), Index(0) {};
+
+  void Init();
+  DWORD GetNextFile(NFind::CFileInfo &fi, bool &filled, FString &resPath);
+};
+
+void CDirEnumerator::Init()
+{
+  Enumerators.Clear();
+  Prefixes.Clear();
+  Index = 0;
+}
+
+static DWORD GetNormalizedError()
+{
+  DWORD error = GetLastError();
+  return (error == 0) ? E_FAIL : error;
+}
+
+DWORD CDirEnumerator::GetNextFile(NFind::CFileInfo &fi, bool &filled, FString &resPath)
+{
+  filled = false;
+  resPath.Empty();
+  
+  for (;;)
+  {
+    #if defined(_WIN32) && !defined(UNDER_CE)
+    bool isRootPrefix = (BasePrefix.IsEmpty() || (NName::IsSuperPath(BasePrefix) && BasePrefix[NName::kSuperPathPrefixSize] == 0));
+    #endif
+
+    if (Enumerators.IsEmpty())
+    {
+      if (Index >= FilePaths.Size())
+        return S_OK;
+      const FString &path = FilePaths[Index++];
+      int pos = path.ReverseFind_PathSepar();
+      if (pos >= 0)
+        resPath.SetFrom(path, pos + 1);
+
+      #if defined(_WIN32) && !defined(UNDER_CE)
+      if (isRootPrefix && path.Len() == 2 && NName::IsDrivePath2(path))
+      {
+        // we use "c:" item as directory item
+        fi.ClearBase();
+        fi.Name = path;
+        fi.SetAsDir();
+        fi.Size = 0;
+      }
+      else
+      #endif
+      if (!fi.Find(BasePrefix + path))
+      {
+        DWORD error = GetNormalizedError();
+        resPath = path;
+        return error;
+      }
+    
+      break;
+    }
+    
+    bool found;
+    
+    if (Enumerators.Back().Next(fi, found))
+    {
+      if (found)
+      {
+        resPath = Prefixes.Back();
+        break;
+      }
+    }
+    else
+    {
+      DWORD error = GetNormalizedError();
+      resPath = Prefixes.Back();
+      Enumerators.DeleteBack();
+      Prefixes.DeleteBack();
+      return error;
+    }
+    
+    Enumerators.DeleteBack();
+    Prefixes.DeleteBack();
+  }
+  
+  resPath += fi.Name;
+  
+  if (EnterToDirs && fi.IsDir())
+  {
+    FString s = resPath;
+    s.Add_PathSepar();
+    Prefixes.Add(s);
+    Enumerators.AddNew().SetDirPrefix(BasePrefix + s);
+  }
+  
+  filled = true;
+  return S_OK;
+}
+
+
+
+class CThreadCrc: public CProgressThreadVirt
+{
+  bool ResultsWereShown;
+  bool WasFinished;
+
+  HRESULT ProcessVirt();
+  virtual void ProcessWasFinished_GuiVirt();
+public:
+  CDirEnumerator Enumerator;
+  CHashBundle Hash;
+  // FString FirstFilePath;
+
+  void SetStatus(const UString &s);
+  void AddErrorMessage(DWORD systemError, const FChar *name);
+  void ShowFinalResults(HWND hwnd);
+
+  CThreadCrc():
+    ResultsWereShown(false),
+    WasFinished(false)
+    {}
+};
+
+void CThreadCrc::ShowFinalResults(HWND hwnd)
+{
+  if (WasFinished)
+  if (!ResultsWereShown)
+  {
+    ResultsWereShown = true;
+    ShowHashResults(Hash, hwnd);
+  }
+}
+
+void CThreadCrc::ProcessWasFinished_GuiVirt()
+{
+  ShowFinalResults(*this);
+}
+
+void CThreadCrc::AddErrorMessage(DWORD systemError, const FChar *name)
+{
+  Sync.AddError_Code_Name(systemError, fs2us(Enumerator.BasePrefix + name));
+  Hash.NumErrors++;
+}
+
+void CThreadCrc::SetStatus(const UString &s2)
+{
+  UString s = s2;
+  if (!Enumerator.BasePrefix.IsEmpty())
+  {
+    s.Add_Space_if_NotEmpty();
+    s += fs2us(Enumerator.BasePrefix);
+  }
+  Sync.Set_Status(s);
+}
+
+HRESULT CThreadCrc::ProcessVirt()
+{
+  // Hash.Init();
+  
+  CMyBuffer buf;
+  if (!buf.Allocate(kBufSize))
+    return E_OUTOFMEMORY;
+
+  CProgressSync &sync = Sync;
+  
+  SetStatus(LangString(IDS_SCANNING));
+
+  Enumerator.Init();
+
+  FString path;
+  NFind::CFileInfo fi;
+  UInt64 numFiles = 0;
+  UInt64 numItems = 0, numItems_Prev = 0;
+  UInt64 totalSize = 0;
+
+  for (;;)
+  {
+    bool filled;
+    DWORD error = Enumerator.GetNextFile(fi, filled, path);
+    if (error != 0)
+    {
+      AddErrorMessage(error, path);
+      continue;
+    }
+    if (!filled)
+      break;
+    if (!fi.IsDir())
+    {
+      totalSize += fi.Size;
+      numFiles++;
+    }
+    numItems++;
+    bool needPrint = false;
+    // if (fi.IsDir())
+    {
+      if (numItems - numItems_Prev >= 100)
+      {
+        needPrint = true;
+        numItems_Prev = numItems;
+      }
+    }
+    /*
+    else if (numFiles - numFiles_Prev >= 200)
+    {
+      needPrint = true;
+      numFiles_Prev = numFiles;
+    }
+    */
+    if (needPrint)
+    {
+      RINOK(sync.ScanProgress(numFiles, totalSize, path, fi.IsDir()));
+    }
+  }
+  RINOK(sync.ScanProgress(numFiles, totalSize, FString(), false));
+  // sync.SetNumFilesTotal(numFiles);
+  // sync.SetProgress(totalSize, 0);
+  // SetStatus(LangString(IDS_CHECKSUM_CALCULATING));
+  // sync.SetCurFilePath(L"");
+  SetStatus(L"");
+ 
+  Enumerator.Init();
+
+  FString tempPath;
+  bool isFirstFile = true;
+  UInt64 errorsFilesSize = 0;
+
+  for (;;)
+  {
+    bool filled;
+    DWORD error = Enumerator.GetNextFile(fi, filled, path);
+    if (error != 0)
+    {
+      AddErrorMessage(error, path);
+      continue;
+    }
+    if (!filled)
+      break;
+    
+    error = 0;
+    Hash.InitForNewFile();
+    if (!fi.IsDir())
+    {
+      NIO::CInFile inFile;
+      tempPath = Enumerator.BasePrefix_for_Open;
+      tempPath += path;
+      if (!inFile.Open(tempPath))
+      {
+        error = GetNormalizedError();
+        AddErrorMessage(error, path);
+        continue;
+      }
+      if (isFirstFile)
+      {
+        Hash.FirstFileName = fs2us(path);
+        isFirstFile = false;
+      }
+      sync.Set_FilePath(fs2us(path));
+      sync.Set_NumFilesCur(Hash.NumFiles);
+      UInt64 progress_Prev = 0;
+      for (;;)
+      {
+        UInt32 size;
+        if (!inFile.Read(buf, kBufSize, size))
+        {
+          error = GetNormalizedError();
+          AddErrorMessage(error, path);
+          UInt64 errorSize = 0;
+          if (inFile.GetLength(errorSize))
+            errorsFilesSize += errorSize;
+          break;
+        }
+        if (size == 0)
+          break;
+        Hash.Update(buf, size);
+        if (Hash.CurSize - progress_Prev >= ((UInt32)1 << 21))
+        {
+          RINOK(sync.Set_NumBytesCur(errorsFilesSize + Hash.FilesSize + Hash.CurSize));
+          progress_Prev = Hash.CurSize;
+        }
+      }
+    }
+    if (error == 0)
+      Hash.Final(fi.IsDir(), false, fs2us(path));
+    RINOK(sync.Set_NumBytesCur(errorsFilesSize + Hash.FilesSize));
+  }
+  RINOK(sync.Set_NumBytesCur(errorsFilesSize + Hash.FilesSize));
+  sync.Set_NumFilesCur(Hash.NumFiles);
+  if (Hash.NumFiles != 1)
+    sync.Set_FilePath(L"");
+  SetStatus(L"");
+
+  CProgressMessageBoxPair &pair = GetMessagePair(Hash.NumErrors != 0);
+  WasFinished = true;
+  LangString(IDS_CHECKSUM_INFORMATION, pair.Title);
+  return S_OK;
+}
+
+
+
+HRESULT CApp::CalculateCrc2(const UString &methodName)
+{
+  unsigned srcPanelIndex = GetFocusedPanelIndex();
+  CPanel &srcPanel = Panels[srcPanelIndex];
+
+  CRecordVector<UInt32> indices;
+  srcPanel.GetOperatedIndicesSmart(indices);
+  if (indices.IsEmpty())
+    return S_OK;
+
+  if (!srcPanel.Is_IO_FS_Folder())
+  {
+    CCopyToOptions options;
+    options.streamMode = true;
+    options.showErrorMessages = true;
+    options.hashMethods.Add(methodName);
+
+    UStringVector messages;
+    return srcPanel.CopyTo(options, indices, &messages);
+  }
+
+  #ifdef EXTERNAL_CODECS
+
+  LoadGlobalCodecs();
+    
+  #endif
+
+  {
+    CThreadCrc t;
+
+    {
+      UStringVector methods;
+      methods.Add(methodName);
+      RINOK(t.Hash.SetMethods(EXTERNAL_CODECS_VARS_G methods));
+    }
+    
+    FOR_VECTOR (i, indices)
+      t.Enumerator.FilePaths.Add(us2fs(srcPanel.GetItemRelPath(indices[i])));
+
+    if (t.Enumerator.FilePaths.Size() == 1)
+      t.Hash.MainName = fs2us(t.Enumerator.FilePaths[0]);
+
+    UString basePrefix = srcPanel.GetFsPath();
+    UString basePrefix2 = basePrefix;
+    if (basePrefix2.Back() == ':')
+    {
+      int pos = basePrefix2.ReverseFind_PathSepar();
+      if (pos >= 0)
+        basePrefix2.DeleteFrom((unsigned)(pos + 1));
+    }
+
+    t.Enumerator.BasePrefix = us2fs(basePrefix);
+    t.Enumerator.BasePrefix_for_Open = us2fs(basePrefix2);
+
+    t.Enumerator.EnterToDirs = !GetFlatMode();
+    
+    t.ShowCompressionInfo = false;
+    
+    UString title = LangString(IDS_CHECKSUM_CALCULATING);
+    
+    t.MainWindow = _window;
+    t.MainTitle = "7-Zip"; // LangString(IDS_APP_TITLE);
+    t.MainAddTitle = title;
+    t.MainAddTitle.Add_Space();
+    
+    RINOK(t.Create(title, _window));
+
+    t.ShowFinalResults(_window);
+  }
+
+  RefreshTitleAlways();
+  return S_OK;
+}
+
+void CApp::CalculateCrc(const char *methodName)
+{
+  HRESULT res = CalculateCrc2(UString(methodName));
+  if (res != S_OK && res != E_ABORT)
+  {
+    unsigned srcPanelIndex = GetFocusedPanelIndex();
+    CPanel &srcPanel = Panels[srcPanelIndex];
+    srcPanel.MessageBox_Error_HRESULT(res);
+  }
+}
diff --git a/CPP/7zip/UI/FileManager/PanelDrag.cpp b/CPP/7zip/UI/FileManager/PanelDrag.cpp
new file mode 100644
index 0000000..af8799c
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelDrag.cpp
@@ -0,0 +1,956 @@
+// PanelDrag.cpp
+
+#include "StdAfx.h"
+
+#ifdef UNDER_CE
+#include <winuserm.h>
+#endif
+
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/MemoryGlobal.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/Shell.h"
+
+#include "../Common/ArchiveName.h"
+#include "../Common/CompressCall.h"
+#include "../Common/ExtractingFilePath.h"
+
+#include "MessagesDialog.h"
+
+#include "App.h"
+#include "EnumFormatEtc.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+#define kTempDirPrefix FTEXT("7zE")
+
+static LPCTSTR const kSvenZipSetFolderFormat = TEXT("7-Zip::SetTargetFolder");
+
+////////////////////////////////////////////////////////
+
+class CDataObject:
+  public IDataObject,
+  public CMyUnknownImp
+{
+private:
+  FORMATETC m_Etc;
+  UINT m_SetFolderFormat;
+
+public:
+  MY_UNKNOWN_IMP1_MT(IDataObject)
+
+  STDMETHODIMP GetData(LPFORMATETC pformatetcIn, LPSTGMEDIUM medium);
+  STDMETHODIMP GetDataHere(LPFORMATETC pformatetc, LPSTGMEDIUM medium);
+  STDMETHODIMP QueryGetData(LPFORMATETC pformatetc );
+
+  STDMETHODIMP GetCanonicalFormatEtc ( LPFORMATETC /* pformatetc */, LPFORMATETC pformatetcOut)
+    { pformatetcOut->ptd = NULL; return ResultFromScode(E_NOTIMPL); }
+
+  STDMETHODIMP SetData(LPFORMATETC etc, STGMEDIUM *medium, BOOL release);
+  STDMETHODIMP EnumFormatEtc(DWORD drection, LPENUMFORMATETC *enumFormatEtc);
+  
+  STDMETHODIMP DAdvise(FORMATETC * /* etc */, DWORD /* advf */, LPADVISESINK /* pAdvSink */, DWORD * /* pdwConnection */)
+    { return OLE_E_ADVISENOTSUPPORTED; }
+  STDMETHODIMP DUnadvise(DWORD /* dwConnection */) { return OLE_E_ADVISENOTSUPPORTED; }
+  STDMETHODIMP EnumDAdvise( LPENUMSTATDATA * /* ppenumAdvise */) { return OLE_E_ADVISENOTSUPPORTED; }
+
+  CDataObject();
+
+  NMemory::CGlobal hGlobal;
+  UString Path;
+};
+
+CDataObject::CDataObject()
+{
+  m_SetFolderFormat = RegisterClipboardFormat(kSvenZipSetFolderFormat);
+  m_Etc.cfFormat = CF_HDROP;
+  m_Etc.ptd = NULL;
+  m_Etc.dwAspect = DVASPECT_CONTENT;
+  m_Etc.lindex = -1;
+  m_Etc.tymed = TYMED_HGLOBAL;
+}
+
+STDMETHODIMP CDataObject::SetData(LPFORMATETC etc, STGMEDIUM *medium, BOOL /* release */)
+{
+  if (etc->cfFormat == m_SetFolderFormat
+      && etc->tymed == TYMED_HGLOBAL
+      && etc->dwAspect == DVASPECT_CONTENT
+      && medium->tymed == TYMED_HGLOBAL)
+  {
+    Path.Empty();
+    if (!medium->hGlobal)
+      return S_OK;
+    size_t size = GlobalSize(medium->hGlobal) / sizeof(wchar_t);
+    const wchar_t *src = (const wchar_t *)GlobalLock(medium->hGlobal);
+    if (src)
+    {
+      for (size_t i = 0; i < size; i++)
+      {
+        wchar_t c = src[i];
+        if (c == 0)
+          break;
+        Path += c;
+      }
+      GlobalUnlock(medium->hGlobal);
+      return S_OK;
+    }
+  }
+  return E_NOTIMPL;
+}
+
+static HGLOBAL DuplicateGlobalMem(HGLOBAL srcGlobal)
+{
+  SIZE_T size = GlobalSize(srcGlobal);
+  const void *src = GlobalLock(srcGlobal);
+  if (!src)
+    return 0;
+  HGLOBAL destGlobal = GlobalAlloc(GHND | GMEM_SHARE, size);
+  if (destGlobal)
+  {
+    void *dest = GlobalLock(destGlobal);
+    if (!dest)
+    {
+      GlobalFree(destGlobal);
+      destGlobal = 0;
+    }
+    else
+    {
+      memcpy(dest, src, size);
+      GlobalUnlock(destGlobal);
+    }
+  }
+  GlobalUnlock(srcGlobal);
+  return destGlobal;
+}
+
+STDMETHODIMP CDataObject::GetData(LPFORMATETC etc, LPSTGMEDIUM medium)
+{
+  RINOK(QueryGetData(etc));
+  medium->tymed = m_Etc.tymed;
+  medium->pUnkForRelease = 0;
+  medium->hGlobal = DuplicateGlobalMem(hGlobal);
+  if (!medium->hGlobal)
+    return E_OUTOFMEMORY;
+  return S_OK;
+}
+
+STDMETHODIMP CDataObject::GetDataHere(LPFORMATETC /* etc */, LPSTGMEDIUM /* medium */)
+{
+  // Seems Windows doesn't call it, so we will not implement it.
+  return E_UNEXPECTED;
+}
+
+
+STDMETHODIMP CDataObject::QueryGetData(LPFORMATETC etc)
+{
+  if ((m_Etc.tymed & etc->tymed) &&
+       m_Etc.cfFormat == etc->cfFormat &&
+       m_Etc.dwAspect == etc->dwAspect)
+    return S_OK;
+  return DV_E_FORMATETC;
+}
+
+STDMETHODIMP CDataObject::EnumFormatEtc(DWORD direction, LPENUMFORMATETC FAR* enumFormatEtc)
+{
+  if (direction != DATADIR_GET)
+    return E_NOTIMPL;
+  return CreateEnumFormatEtc(1, &m_Etc, enumFormatEtc);
+}
+
+////////////////////////////////////////////////////////
+
+class CDropSource:
+  public IDropSource,
+  public CMyUnknownImp
+{
+  DWORD m_Effect;
+public:
+  MY_UNKNOWN_IMP1_MT(IDropSource)
+  STDMETHOD(QueryContinueDrag)(BOOL escapePressed, DWORD keyState);
+  STDMETHOD(GiveFeedback)(DWORD effect);
+
+
+  bool NeedExtract;
+  CPanel *Panel;
+  CRecordVector<UInt32> Indices;
+  UString Folder;
+  CDataObject *DataObjectSpec;
+  CMyComPtr<IDataObject> DataObject;
+  
+  bool NeedPostCopy;
+  HRESULT Result;
+  UStringVector Messages;
+
+  CDropSource(): m_Effect(DROPEFFECT_NONE), Panel(NULL), NeedPostCopy(false), Result(S_OK) {}
+};
+
+STDMETHODIMP CDropSource::QueryContinueDrag(BOOL escapePressed, DWORD keyState)
+{
+  if (escapePressed == TRUE)
+    return DRAGDROP_S_CANCEL;
+  if ((keyState & MK_LBUTTON) == 0)
+  {
+    if (m_Effect == DROPEFFECT_NONE)
+      return DRAGDROP_S_CANCEL;
+    Result = S_OK;
+    bool needExtract = NeedExtract;
+    // MoveMode = (((keyState & MK_SHIFT) != 0) && MoveIsAllowed);
+    if (!DataObjectSpec->Path.IsEmpty())
+    {
+      needExtract = false;
+      NeedPostCopy = true;
+    }
+    if (needExtract)
+    {
+      CCopyToOptions options;
+      options.folder = Folder;
+
+      // 15.13: fixed problem with mouse cursor for password window.
+      // DoDragDrop() probably calls SetCapture() to some hidden window.
+      // But it's problem, if we show some modal window, like MessageBox.
+      // So we return capture to our window.
+      // If you know better way to solve the problem, please notify 7-Zip developer.
+      
+      // MessageBoxW(*Panel, L"test", L"test", 0);
+
+      /* HWND oldHwnd = */ SetCapture(*Panel);
+
+      Result = Panel->CopyTo(options, Indices, &Messages);
+
+      // do we need to restore capture?
+      // ReleaseCapture();
+      // oldHwnd = SetCapture(oldHwnd);
+
+      if (Result != S_OK || !Messages.IsEmpty())
+        return DRAGDROP_S_CANCEL;
+    }
+    return DRAGDROP_S_DROP;
+  }
+  return S_OK;
+}
+
+STDMETHODIMP CDropSource::GiveFeedback(DWORD effect)
+{
+  m_Effect = effect;
+  return DRAGDROP_S_USEDEFAULTCURSORS;
+}
+
+static bool CopyNamesToHGlobal(NMemory::CGlobal &hgDrop, const UStringVector &names)
+{
+  size_t totalLen = 1;
+
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    AStringVector namesA;
+    unsigned i;
+    for (i = 0; i < names.Size(); i++)
+      namesA.Add(GetSystemString(names[i]));
+    for (i = 0; i < names.Size(); i++)
+      totalLen += namesA[i].Len() + 1;
+    
+    if (!hgDrop.Alloc(GHND | GMEM_SHARE, totalLen * sizeof(CHAR) + sizeof(DROPFILES)))
+      return false;
+    
+    NMemory::CGlobalLock dropLock(hgDrop);
+    DROPFILES* dropFiles = (DROPFILES*)dropLock.GetPointer();
+    if (!dropFiles)
+      return false;
+    dropFiles->fNC = FALSE;
+    dropFiles->pt.x = 0;
+    dropFiles->pt.y = 0;
+    dropFiles->pFiles = sizeof(DROPFILES);
+    dropFiles->fWide = FALSE;
+    CHAR *p = (CHAR *)((BYTE *)dropFiles + sizeof(DROPFILES));
+    for (i = 0; i < names.Size(); i++)
+    {
+      const AString &s = namesA[i];
+      unsigned fullLen = s.Len() + 1;
+      MyStringCopy(p, (const char *)s);
+      p += fullLen;
+      totalLen -= fullLen;
+    }
+    *p = 0;
+  }
+  else
+  #endif
+  {
+    unsigned i;
+    for (i = 0; i < names.Size(); i++)
+      totalLen += names[i].Len() + 1;
+    
+    if (!hgDrop.Alloc(GHND | GMEM_SHARE, totalLen * sizeof(WCHAR) + sizeof(DROPFILES)))
+      return false;
+    
+    NMemory::CGlobalLock dropLock(hgDrop);
+    DROPFILES* dropFiles = (DROPFILES*)dropLock.GetPointer();
+    if (!dropFiles)
+      return false;
+    dropFiles->fNC = FALSE;
+    dropFiles->pt.x = 0;
+    dropFiles->pt.y = 0;
+    dropFiles->pFiles = sizeof(DROPFILES);
+    dropFiles->fWide = TRUE;
+    WCHAR *p = (WCHAR *) (void *) ((BYTE *)dropFiles + sizeof(DROPFILES));
+    for (i = 0; i < names.Size(); i++)
+    {
+      const UString &s = names[i];
+      unsigned fullLen = s.Len() + 1;
+      MyStringCopy(p, (const WCHAR *)s);
+      p += fullLen;
+      totalLen -= fullLen;
+    }
+    *p = 0;
+  }
+  return true;
+}
+
+void CPanel::OnDrag(LPNMLISTVIEW /* nmListView */)
+{
+  if (!DoesItSupportOperations())
+    return;
+
+  CDisableTimerProcessing disableTimerProcessing2(*this);
+  
+  CRecordVector<UInt32> indices;
+  GetOperatedItemIndices(indices);
+  if (indices.Size() == 0)
+    return;
+
+  // CSelectedState selState;
+  // SaveSelectedState(selState);
+
+  // FString dirPrefix2;
+  FString dirPrefix;
+  CTempDir tempDirectory;
+
+  bool isFSFolder = IsFSFolder();
+  if (isFSFolder)
+    dirPrefix = us2fs(GetFsPath());
+  else
+  {
+    if (!tempDirectory.Create(kTempDirPrefix))
+    {
+      MessageBox_Error(L"Can't create temp folder");
+      return;
+    }
+    dirPrefix = tempDirectory.GetPath();
+    // dirPrefix2 = dirPrefix;
+    NFile::NName::NormalizeDirPathPrefix(dirPrefix);
+  }
+
+  CDataObject *dataObjectSpec = new CDataObject;
+  CMyComPtr<IDataObject> dataObject = dataObjectSpec;
+
+  {
+    UStringVector names;
+
+    // names variable is     USED for drag and drop from 7-zip to Explorer or to 7-zip archive folder.
+    // names variable is NOT USED for drag and drop from 7-zip to 7-zip File System folder.
+
+    FOR_VECTOR (i, indices)
+    {
+      UInt32 index = indices[i];
+      UString s;
+      if (isFSFolder)
+        s = GetItemRelPath(index);
+      else
+      {
+        s = GetItemName(index);
+        /*
+        // We use (keepAndReplaceEmptyPrefixes = true) in CAgentFolder::Extract
+        // So the following code is not required.
+        // Maybe we also can change IFolder interface and send some flag also.
+  
+        if (s.IsEmpty())
+        {
+          // Correct_FsFile_Name("") returns "_".
+          // If extracting code removes empty folder prefixes from path (as it was in old version),
+          // Explorer can't find "_" folder in temp folder.
+          // We can ask Explorer to copy parent temp folder "7zE" instead.
+
+          names.Clear();
+          names.Add(dirPrefix2);
+          break;
+        }
+        */
+        s = Get_Correct_FsFile_Name(s);
+      }
+      names.Add(fs2us(dirPrefix) + s);
+    }
+    if (!CopyNamesToHGlobal(dataObjectSpec->hGlobal, names))
+      return;
+  }
+
+  CDropSource *dropSourceSpec = new CDropSource;
+  CMyComPtr<IDropSource> dropSource = dropSourceSpec;
+  dropSourceSpec->NeedExtract = !isFSFolder;
+  dropSourceSpec->Panel = this;
+  dropSourceSpec->Indices = indices;
+  dropSourceSpec->Folder = fs2us(dirPrefix);
+  dropSourceSpec->DataObjectSpec = dataObjectSpec;
+  dropSourceSpec->DataObject = dataObjectSpec;
+
+ 
+  /*
+  CTime - file creation timestamp.
+  There are two operations in Windows with Drag and Drop:
+    COPY_OPERATION - icon with    Plus sign - CTime will be set as current_time.
+    MOVE_OPERATION - icon without Plus sign - CTime will be preserved
+
+  Note: if we call DoDragDrop() with (effectsOK = DROPEFFECT_MOVE), then
+        it will use MOVE_OPERATION and CTime will be preserved.
+        But MoveFile() function doesn't preserve CTime, if different volumes are used.
+        Why it's so?
+        Does DoDragDrop() use some another function (not MoveFile())?
+
+  if (effectsOK == DROPEFFECT_COPY) it works as COPY_OPERATION
+    
+  if (effectsOK == DROPEFFECT_MOVE) drag works as MOVE_OPERATION
+
+  if (effectsOK == (DROPEFFECT_COPY | DROPEFFECT_MOVE))
+  {
+    if we drag file to same volume, then Windows suggests:
+       CTRL      - COPY_OPERATION
+       [default] - MOVE_OPERATION
+    
+    if we drag file to another volume, then Windows suggests
+       [default] - COPY_OPERATION
+       SHIFT     - MOVE_OPERATION
+  }
+
+  We want to use MOVE_OPERATION for extracting from archive (open in 7-Zip) to Explorer:
+  It has the following advantages:
+    1) it uses fast MOVE_OPERATION instead of slow COPY_OPERATION and DELETE, if same volume.
+    2) it preserved CTime
+
+  Some another programs support only COPY_OPERATION.
+  So we can use (DROPEFFECT_COPY | DROPEFFECT_MOVE)
+
+  Also another program can return from DoDragDrop() before
+  files using. But we delete temp folder after DoDragDrop(),
+  and another program can't open input files in that case.
+
+  We create objects:
+    IDropSource *dropSource
+    IDataObject *dataObject
+  if DropTarget is 7-Zip window, then 7-Zip's
+    IDropTarget::DragOver() sets Path in IDataObject.
+  and
+    IDropSource::QueryContinueDrag() sets NeedPostCopy, if Path is not epmty.
+  So we can detect destination path after DoDragDrop().
+  Now we don't know any good way to detect destination path for D&D to Explorer.
+  */
+
+  bool moveIsAllowed = isFSFolder;
+  /*
+  DWORD effectsOK = DROPEFFECT_COPY;
+  if (moveIsAllowed)
+    effectsOK |= DROPEFFECT_MOVE;
+  */
+
+  // 18.04: was changed
+  DWORD effectsOK = DROPEFFECT_MOVE | DROPEFFECT_COPY;
+
+  DWORD effect;
+  _panelCallback->DragBegin();
+  
+  HRESULT res = DoDragDrop(dataObject, dropSource, effectsOK, &effect);
+  
+  _panelCallback->DragEnd();
+  bool canceled = (res == DRAGDROP_S_CANCEL);
+  
+  CDisableNotify disableNotify(*this);
+  
+  if (res == DRAGDROP_S_DROP)
+  {
+    res = dropSourceSpec->Result;
+    if (dropSourceSpec->NeedPostCopy)
+      if (!dataObjectSpec->Path.IsEmpty())
+      {
+        NFile::NName::NormalizeDirPathPrefix(dataObjectSpec->Path);
+        CCopyToOptions options;
+        options.folder = dataObjectSpec->Path;
+        // if MOVE is not allowed, we just use COPY operation
+        options.moveMode = (effect == DROPEFFECT_MOVE && moveIsAllowed);
+        res = CopyTo(options, indices, &dropSourceSpec->Messages);
+      }
+    /*
+    if (effect == DROPEFFECT_MOVE)
+      RefreshListCtrl(selState);
+    */
+  }
+  else
+  {
+    // we ignore E_UNEXPECTED that is returned if we drag file to printer
+    if (res != DRAGDROP_S_CANCEL && res != S_OK
+        && res != E_UNEXPECTED)
+      MessageBox_Error_HRESULT(res);
+
+    res = dropSourceSpec->Result;
+  }
+
+  if (!dropSourceSpec->Messages.IsEmpty())
+  {
+    CMessagesDialog messagesDialog;
+    messagesDialog.Messages = &dropSourceSpec->Messages;
+    messagesDialog.Create((*this));
+  }
+  
+  if (res != S_OK && res != E_ABORT)
+  {
+    // we restore Notify before MessageBox_Error_HRESULT. So we will se files selection
+    disableNotify.Restore();
+    // SetFocusToList();
+    MessageBox_Error_HRESULT(res);
+  }
+  if (res == S_OK && dropSourceSpec->Messages.IsEmpty() && !canceled)
+    KillSelection();
+}
+
+void CDropTarget::QueryGetData(IDataObject *dataObject)
+{
+  FORMATETC etc = { CF_HDROP, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
+  m_DropIsAllowed = (dataObject->QueryGetData(&etc) == S_OK);
+
+}
+
+static void MySetDropHighlighted(HWND hWnd, int index, bool enable)
+{
+  LVITEM item;
+  item.mask = LVIF_STATE;
+  item.iItem = index;
+  item.iSubItem = 0;
+  item.state = enable ? LVIS_DROPHILITED : 0;
+  item.stateMask = LVIS_DROPHILITED;
+  item.pszText = 0;
+  ListView_SetItem(hWnd, &item);
+}
+
+void CDropTarget::RemoveSelection()
+{
+  if (m_SelectionIndex >= 0 && m_Panel)
+    MySetDropHighlighted(m_Panel->_listView, m_SelectionIndex, false);
+  m_SelectionIndex = -1;
+}
+
+#ifdef UNDER_CE
+#define ChildWindowFromPointEx(hwndParent, pt, uFlags) ChildWindowFromPoint(hwndParent, pt)
+#endif
+
+void CDropTarget::PositionCursor(POINTL ptl)
+{
+  m_SubFolderIndex = -1;
+  POINT pt;
+  pt.x = ptl.x;
+  pt.y = ptl.y;
+
+  RemoveSelection();
+  m_IsAppTarget = true;
+  m_Panel = NULL;
+
+  m_PanelDropIsAllowed = true;
+  if (!m_DropIsAllowed)
+    return;
+  {
+    POINT pt2 = pt;
+    App->_window.ScreenToClient(&pt2);
+    for (unsigned i = 0; i < kNumPanelsMax; i++)
+      if (App->IsPanelVisible(i))
+        if (App->Panels[i].IsEnabled())
+          if (ChildWindowFromPointEx(App->_window, pt2,
+              CWP_SKIPINVISIBLE | CWP_SKIPDISABLED) == (HWND)App->Panels[i])
+          {
+            m_Panel = &App->Panels[i];
+            m_IsAppTarget = false;
+            if ((int)i == SrcPanelIndex)
+            {
+              m_PanelDropIsAllowed = false;
+              return;
+            }
+            break;
+          }
+    if (m_IsAppTarget)
+    {
+      if (TargetPanelIndex >= 0)
+        m_Panel = &App->Panels[TargetPanelIndex];
+      return;
+    }
+  }
+
+  /*
+  m_PanelDropIsAllowed = m_Panel->DoesItSupportOperations();
+  if (!m_PanelDropIsAllowed)
+    return;
+  */
+
+  if (!m_Panel->IsFsOrPureDrivesFolder())
+    return;
+
+  if (WindowFromPoint(pt) != (HWND)m_Panel->_listView)
+    return;
+
+  LVHITTESTINFO info;
+  m_Panel->_listView.ScreenToClient(&pt);
+  info.pt = pt;
+  int index = ListView_HitTest(m_Panel->_listView, &info);
+  if (index < 0)
+    return;
+  int realIndex = m_Panel->GetRealItemIndex(index);
+  if (realIndex == kParentIndex)
+    return;
+  if (!m_Panel->IsItem_Folder(realIndex))
+    return;
+  m_SubFolderIndex = realIndex;
+  m_SubFolderName = m_Panel->GetItemName(m_SubFolderIndex);
+  MySetDropHighlighted(m_Panel->_listView, index, true);
+  m_SelectionIndex = index;
+}
+
+bool CDropTarget::IsFsFolderPath() const
+{
+  if (!m_IsAppTarget && m_Panel)
+    return (m_Panel->IsFSFolder() || (m_Panel->IsFSDrivesFolder() && m_SelectionIndex >= 0));
+  return false;
+}
+
+static void ReadUnicodeStrings(const wchar_t *p, size_t size, UStringVector &names)
+{
+  names.Clear();
+  UString name;
+  for (;size > 0; size--)
+  {
+    wchar_t c = *p++;
+    if (c == 0)
+    {
+      if (name.IsEmpty())
+        break;
+      names.Add(name);
+      name.Empty();
+    }
+    else
+      name += c;
+  }
+}
+
+static void ReadAnsiStrings(const char *p, size_t size, UStringVector &names)
+{
+  names.Clear();
+  AString name;
+  for (;size > 0; size--)
+  {
+    char c = *p++;
+    if (c == 0)
+    {
+      if (name.IsEmpty())
+        break;
+      names.Add(GetUnicodeString(name));
+      name.Empty();
+    }
+    else
+      name += c;
+  }
+}
+
+static void GetNamesFromDataObject(IDataObject *dataObject, UStringVector &names)
+{
+  names.Clear();
+  FORMATETC etc = { CF_HDROP, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
+  STGMEDIUM medium;
+  HRESULT res = dataObject->GetData(&etc, &medium);
+  if (res != S_OK)
+    return;
+  if (medium.tymed != TYMED_HGLOBAL)
+    return;
+  {
+    NMemory::CGlobal global;
+    global.Attach(medium.hGlobal);
+    size_t blockSize = GlobalSize(medium.hGlobal);
+    NMemory::CGlobalLock dropLock(medium.hGlobal);
+    const DROPFILES* dropFiles = (DROPFILES*)dropLock.GetPointer();
+    if (!dropFiles)
+      return;
+    if (blockSize < dropFiles->pFiles)
+      return;
+    size_t size = blockSize - dropFiles->pFiles;
+    const void *namesData = (const Byte *)dropFiles + dropFiles->pFiles;
+    if (dropFiles->fWide)
+      ReadUnicodeStrings((const wchar_t *)namesData, size / sizeof(wchar_t), names);
+    else
+      ReadAnsiStrings((const char *)namesData, size, names);
+  }
+}
+
+bool CDropTarget::IsItSameDrive() const
+{
+  if (!m_Panel)
+    return false;
+  if (!IsFsFolderPath())
+    return false;
+
+  UString drive;
+  
+  if (m_Panel->IsFSFolder())
+  {
+    drive = m_Panel->GetDriveOrNetworkPrefix();
+    if (drive.IsEmpty())
+      return false;
+  }
+  else if (m_Panel->IsFSDrivesFolder() && m_SelectionIndex >= 0)
+  {
+    drive = m_SubFolderName;
+    drive.Add_PathSepar();
+  }
+  else
+    return false;
+
+  if (m_SourcePaths.Size() == 0)
+    return false;
+  
+  FOR_VECTOR (i, m_SourcePaths)
+  {
+    if (!m_SourcePaths[i].IsPrefixedBy_NoCase(drive))
+      return false;
+  }
+  
+  return true;
+}
+
+
+/*
+  There are 2 different actions, when we drag to 7-Zip:
+  1) Drag from any external program except of Explorer to "7-Zip" FS folder.
+     We want to create new archive for that operation.
+  2) all another operation work as usual file COPY/MOVE
+    - Drag from "7-Zip" FS to "7-Zip" FS.
+        COPY/MOVE are supported.
+    - Drag to open archive in 7-Zip.
+        We want to update archive.
+        We replace COPY to MOVE.
+    - Drag from "7-Zip" archive to "7-Zip" FS.
+        We replace COPY to MOVE.
+*/
+
+DWORD CDropTarget::GetEffect(DWORD keyState, POINTL /* pt */, DWORD allowedEffect)
+{
+  if (!m_DropIsAllowed || !m_PanelDropIsAllowed)
+    return DROPEFFECT_NONE;
+
+  if (!IsFsFolderPath() || !m_SetPathIsOK)
+    allowedEffect &= ~DROPEFFECT_MOVE;
+
+  DWORD effect = 0;
+  
+  if (keyState & MK_CONTROL)
+    effect = allowedEffect & DROPEFFECT_COPY;
+  else if (keyState & MK_SHIFT)
+    effect = allowedEffect & DROPEFFECT_MOVE;
+  
+  if (effect == 0)
+  {
+    if (allowedEffect & DROPEFFECT_COPY)
+    effect = DROPEFFECT_COPY;
+    if (allowedEffect & DROPEFFECT_MOVE)
+    {
+      if (IsItSameDrive())
+        effect = DROPEFFECT_MOVE;
+    }
+  }
+  if (effect == 0)
+    return DROPEFFECT_NONE;
+  return effect;
+}
+
+UString CDropTarget::GetTargetPath() const
+{
+  if (!IsFsFolderPath())
+    return UString();
+  UString path = m_Panel->GetFsPath();
+  if (m_SubFolderIndex >= 0 && !m_SubFolderName.IsEmpty())
+  {
+    path += m_SubFolderName;
+    path.Add_PathSepar();
+  }
+  return path;
+}
+
+bool CDropTarget::SetPath(bool enablePath) const
+{
+  UINT setFolderFormat = RegisterClipboardFormat(kSvenZipSetFolderFormat);
+  
+  FORMATETC etc = { (CLIPFORMAT)setFolderFormat, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
+  STGMEDIUM medium;
+  medium.tymed = etc.tymed;
+  medium.pUnkForRelease = 0;
+  UString path;
+  if (enablePath)
+    path = GetTargetPath();
+  size_t size = path.Len() + 1;
+  medium.hGlobal = GlobalAlloc(GHND | GMEM_SHARE, size * sizeof(wchar_t));
+  if (!medium.hGlobal)
+    return false;
+  wchar_t *dest = (wchar_t *)GlobalLock(medium.hGlobal);
+  if (!dest)
+  {
+    GlobalUnlock(medium.hGlobal);
+    return false;
+  }
+  MyStringCopy(dest, (const wchar_t *)path);
+  GlobalUnlock(medium.hGlobal);
+  bool res = m_DataObject->SetData(&etc, &medium, FALSE) == S_OK;
+  GlobalFree(medium.hGlobal);
+  return res;
+}
+
+bool CDropTarget::SetPath()
+{
+  m_SetPathIsOK = SetPath(m_DropIsAllowed && m_PanelDropIsAllowed && IsFsFolderPath());
+  return m_SetPathIsOK;
+}
+
+STDMETHODIMP CDropTarget::DragEnter(IDataObject * dataObject, DWORD keyState,
+      POINTL pt, DWORD *effect)
+{
+  GetNamesFromDataObject(dataObject, m_SourcePaths);
+  QueryGetData(dataObject);
+  m_DataObject = dataObject;
+  return DragOver(keyState, pt, effect);
+}
+
+
+STDMETHODIMP CDropTarget::DragOver(DWORD keyState, POINTL pt, DWORD *effect)
+{
+  PositionCursor(pt);
+  SetPath();
+  *effect = GetEffect(keyState, pt, *effect);
+  return S_OK;
+}
+
+
+STDMETHODIMP CDropTarget::DragLeave()
+{
+  RemoveSelection();
+  SetPath(false);
+  m_DataObject.Release();
+  return S_OK;
+}
+
+// We suppose that there was ::DragOver for same POINTL_pt before ::Drop
+// So SetPath() is same as in Drop.
+
+STDMETHODIMP CDropTarget::Drop(IDataObject *dataObject, DWORD keyState,
+      POINTL pt, DWORD * effect)
+{
+  QueryGetData(dataObject);
+  PositionCursor(pt);
+  m_DataObject = dataObject;
+  bool needDrop = true;
+  if (m_DropIsAllowed && m_PanelDropIsAllowed)
+    if (IsFsFolderPath())
+      needDrop = !SetPath();
+  *effect = GetEffect(keyState, pt, *effect);
+  if (m_DropIsAllowed && m_PanelDropIsAllowed)
+  {
+    if (needDrop)
+    {
+      UString path = GetTargetPath();
+      if (m_IsAppTarget && m_Panel)
+        if (m_Panel->IsFSFolder())
+          path = m_Panel->GetFsPath();
+      m_Panel->DropObject(dataObject, path);
+    }
+  }
+  RemoveSelection();
+  m_DataObject.Release();
+  return S_OK;
+}
+
+void CPanel::DropObject(IDataObject *dataObject, const UString &folderPath)
+{
+  UStringVector names;
+  GetNamesFromDataObject(dataObject, names);
+  CompressDropFiles(names, folderPath);
+}
+
+/*
+void CPanel::CompressDropFiles(HDROP dr)
+{
+  UStringVector fileNames;
+  {
+    NShell::CDrop drop(true);
+    drop.Attach(dr);
+    drop.QueryFileNames(fileNames);
+  }
+  CompressDropFiles(fileNamesUnicode);
+}
+*/
+
+static bool IsFolderInTemp(const FString &path)
+{
+  FString tempPath;
+  if (!MyGetTempPath(tempPath))
+    return false;
+  if (tempPath.IsEmpty())
+    return false;
+  unsigned len = tempPath.Len();
+  if (path.Len() < len)
+    return false;
+  return CompareFileNames(path.Left(len), tempPath) == 0;
+}
+
+static bool AreThereNamesFromTemp(const UStringVector &fileNames)
+{
+  FString tempPathF;
+  if (!MyGetTempPath(tempPathF))
+    return false;
+  UString tempPath = fs2us(tempPathF);
+  if (tempPath.IsEmpty())
+    return false;
+  FOR_VECTOR (i, fileNames)
+    if (fileNames[i].IsPrefixedBy_NoCase(tempPath))
+      return true;
+  return false;
+}
+
+void CPanel::CompressDropFiles(const UStringVector &fileNames, const UString &folderPath)
+{
+  if (fileNames.Size() == 0)
+    return;
+  bool createNewArchive = true;
+  if (!IsFSFolder())
+    createNewArchive = !DoesItSupportOperations();
+
+  if (createNewArchive)
+  {
+    UString folderPath2 = folderPath;
+    if (folderPath2.IsEmpty())
+    {
+      FString folderPath2F;
+      GetOnlyDirPrefix(us2fs(fileNames.Front()), folderPath2F);
+      folderPath2 = fs2us(folderPath2F);
+      if (IsFolderInTemp(folderPath2F))
+        folderPath2 = ROOT_FS_FOLDER;
+    }
+    
+    const UString arcName = CreateArchiveName(fileNames);
+    
+    CompressFiles(folderPath2, arcName, L"",
+      true, // addExtension
+      fileNames,
+      false, // email
+      true, // showDialog
+      AreThereNamesFromTemp(fileNames) // waitFinish
+      );
+  }
+  else
+    CopyFromAsk(fileNames);
+}
diff --git a/CPP/7zip/UI/FileManager/PanelFolderChange.cpp b/CPP/7zip/UI/FileManager/PanelFolderChange.cpp
new file mode 100644
index 0000000..b91195f
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelFolderChange.cpp
@@ -0,0 +1,879 @@
+// PanelFolderChange.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "../../PropID.h"
+
+#ifdef UNDER_CE
+#include "FSFolder.h"
+#else
+#include "FSDrives.h"
+#endif
+#include "LangUtils.h"
+#include "ListViewDialog.h"
+#include "Panel.h"
+#include "RootFolder.h"
+#include "ViewSettings.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NFind;
+
+void CPanel::ReleaseFolder()
+{
+  DeleteListItems();
+
+  _folder.Release();
+
+  _folderCompare.Release();
+  _folderGetItemName.Release();
+  _folderRawProps.Release();
+  _folderAltStreams.Release();
+  _folderOperations.Release();
+  
+  _thereAreDeletedItems = false;
+}
+
+void CPanel::SetNewFolder(IFolderFolder *newFolder)
+{
+  ReleaseFolder();
+  _folder = newFolder;
+  if (_folder)
+  {
+    _folder.QueryInterface(IID_IFolderCompare, &_folderCompare);
+    _folder.QueryInterface(IID_IFolderGetItemName, &_folderGetItemName);
+    _folder.QueryInterface(IID_IArchiveGetRawProps, &_folderRawProps);
+    _folder.QueryInterface(IID_IFolderAltStreams, &_folderAltStreams);
+    _folder.QueryInterface(IID_IFolderOperations, &_folderOperations);
+  }
+}
+
+void CPanel::SetToRootFolder()
+{
+  ReleaseFolder();
+  _library.Free();
+  
+  CRootFolder *rootFolderSpec = new CRootFolder;
+  SetNewFolder(rootFolderSpec);
+  rootFolderSpec->Init();
+}
+
+
+static bool DoesNameContainWildcard_SkipRoot(const UString &path)
+{
+  return DoesNameContainWildcard(path.Ptr(NName::GetRootPrefixSize(path)));
+}
+
+HRESULT CPanel::BindToPath(const UString &fullPath, const UString &arcFormat, COpenResult &openRes)
+{
+  UString path = fullPath;
+  #ifdef _WIN32
+  path.Replace(L'/', WCHAR_PATH_SEPARATOR);
+  #endif
+
+  openRes.ArchiveIsOpened = false;
+  openRes.Encrypted = false;
+  
+  CDisableTimerProcessing disableTimerProcessing(*this);
+  CDisableNotify disableNotify(*this);
+
+  for (; !_parentFolders.IsEmpty(); CloseOneLevel())
+  {
+    // ---------- we try to use open archive ----------
+
+    const CFolderLink &link = _parentFolders.Back();
+    const UString &virtPath = link.VirtualPath;
+    if (!path.IsPrefixedBy(virtPath))
+      continue;
+    UString relatPath = path.Ptr(virtPath.Len());
+    if (!relatPath.IsEmpty())
+    {
+      if (!IS_PATH_SEPAR(relatPath[0]))
+        continue;
+      else
+        relatPath.Delete(0);
+    }
+    
+    UString relatPath2 = relatPath;
+    if (!relatPath2.IsEmpty() && !IS_PATH_SEPAR(relatPath2.Back()))
+      relatPath2.Add_PathSepar();
+
+    for (;;)
+    {
+      const UString foldPath = GetFolderPath(_folder);
+      if (relatPath2 == foldPath)
+        break;
+      if (relatPath.IsPrefixedBy(foldPath))
+      {
+        path = relatPath.Ptr(foldPath.Len());
+        break;
+      }
+      CMyComPtr<IFolderFolder> newFolder;
+      if (_folder->BindToParentFolder(&newFolder) != S_OK)
+        throw 20140918;
+      if (!newFolder) // we exit from loop above if (relatPath.IsPrefixedBy(empty path for root folder)
+        throw 20140918;
+      SetNewFolder(newFolder);
+    }
+    break;
+  }
+
+  if (_parentFolders.IsEmpty())
+  {
+    // ---------- we open file or folder from file system ----------
+
+    CloseOpenFolders();
+    UString sysPath = path;
+    
+    unsigned prefixSize = NName::GetRootPrefixSize(sysPath);
+    if (prefixSize == 0 || sysPath[prefixSize] == 0)
+      sysPath.Empty();
+    
+    #if defined(_WIN32) && !defined(UNDER_CE)
+    if (!sysPath.IsEmpty() && sysPath.Back() == ':' &&
+      (sysPath.Len() != 2 || !NName::IsDrivePath2(sysPath)))
+    {
+      UString baseFile = sysPath;
+      baseFile.DeleteBack();
+      if (NFind::DoesFileOrDirExist(us2fs(baseFile)))
+        sysPath.Empty();
+    }
+    #endif
+    
+    CFileInfo fileInfo;
+    
+    while (!sysPath.IsEmpty())
+    {
+      if (fileInfo.Find(us2fs(sysPath)))
+        break;
+      int pos = sysPath.ReverseFind_PathSepar();
+      if (pos < 0)
+        sysPath.Empty();
+      else
+      {
+        /*
+        if (reducedParts.Size() > 0 || pos < (int)sysPath.Len() - 1)
+          reducedParts.Add(sysPath.Ptr(pos + 1));
+        */
+        #if defined(_WIN32) && !defined(UNDER_CE)
+        if (pos == 2 && NName::IsDrivePath2(sysPath) && sysPath.Len() > 3)
+          pos++;
+        #endif
+
+        sysPath.DeleteFrom((unsigned)pos);
+      }
+    }
+    
+    SetToRootFolder();
+
+    CMyComPtr<IFolderFolder> newFolder;
+  
+    if (sysPath.IsEmpty())
+    {
+      _folder->BindToFolder(path, &newFolder);
+    }
+    else if (fileInfo.IsDir())
+    {
+      #ifdef _WIN32
+      if (DoesNameContainWildcard_SkipRoot(sysPath))
+      {
+        FString dirPrefix, fileName;
+        NDir::GetFullPathAndSplit(us2fs(sysPath), dirPrefix, fileName);
+        if (DoesNameContainWildcard_SkipRoot(fs2us(dirPrefix)))
+          return E_INVALIDARG;
+        sysPath = fs2us(dirPrefix + fileInfo.Name);
+      }
+      #endif
+
+      NName::NormalizeDirPathPrefix(sysPath);
+      _folder->BindToFolder(sysPath, &newFolder);
+    }
+    else
+    {
+      FString dirPrefix, fileName;
+      
+      NDir::GetFullPathAndSplit(us2fs(sysPath), dirPrefix, fileName);
+
+      HRESULT res = S_OK;
+      
+      #ifdef _WIN32
+      if (DoesNameContainWildcard_SkipRoot(fs2us(dirPrefix)))
+        return E_INVALIDARG;
+
+      if (DoesNameContainWildcard(fs2us(fileName)))
+        res = S_FALSE;
+      else
+      #endif
+      {
+        CTempFileInfo tfi;
+        tfi.RelPath = fs2us(fileName);
+        tfi.FolderPath = dirPrefix;
+        tfi.FilePath = us2fs(sysPath);
+        res = OpenAsArc(NULL, tfi, sysPath, arcFormat, openRes);
+      }
+      
+      if (res == S_FALSE)
+        _folder->BindToFolder(fs2us(dirPrefix), &newFolder);
+      else
+      {
+        RINOK(res);
+        openRes.ArchiveIsOpened = true;
+        _parentFolders.Back().ParentFolderPath = fs2us(dirPrefix);
+        path.DeleteFrontal(sysPath.Len());
+        if (!path.IsEmpty() && IS_PATH_SEPAR(path[0]))
+          path.Delete(0);
+      }
+    }
+    
+    if (newFolder)
+    {
+      SetNewFolder(newFolder);
+      // LoadFullPath();
+      return S_OK;
+    }
+  }
+  
+  {
+    // ---------- we open folder remPath in archive and sub archives ----------
+
+    for (unsigned curPos = 0; curPos != path.Len();)
+    {
+      UString s = path.Ptr(curPos);
+      int slashPos = NName::FindSepar(s);
+      unsigned skipLen = s.Len();
+      if (slashPos >= 0)
+      {
+        s.DeleteFrom((unsigned)slashPos);
+        skipLen = slashPos + 1;
+      }
+
+      CMyComPtr<IFolderFolder> newFolder;
+      _folder->BindToFolder(s, &newFolder);
+      if (newFolder)
+        curPos += skipLen;
+      else if (_folderAltStreams)
+      {
+        int pos = s.Find(L':');
+        if (pos >= 0)
+        {
+          UString baseName = s;
+          baseName.DeleteFrom((unsigned)pos);
+          if (_folderAltStreams->BindToAltStreams(baseName, &newFolder) == S_OK && newFolder)
+            curPos += pos + 1;
+        }
+      }
+      
+      if (!newFolder)
+        break;
+
+      SetNewFolder(newFolder);
+    }
+  }
+
+  return S_OK;
+}
+
+HRESULT CPanel::BindToPathAndRefresh(const UString &path)
+{
+  CDisableTimerProcessing disableTimerProcessing(*this);
+  CDisableNotify disableNotify(*this);
+  COpenResult openRes;
+  UString s = path;
+  
+  #ifdef _WIN32
+    if (!s.IsEmpty() && s[0] == '\"' && s.Back() == '\"')
+    {
+      s.DeleteBack();
+      s.Delete(0);
+    }
+  #endif
+
+  HRESULT res = BindToPath(s, UString(), openRes);
+  RefreshListCtrl();
+  return res;
+}
+
+void CPanel::SetBookmark(unsigned index)
+{
+  _appState->FastFolders.SetString(index, _currentFolderPrefix);
+}
+
+void CPanel::OpenBookmark(unsigned index)
+{
+  BindToPathAndRefresh(_appState->FastFolders.GetString(index));
+}
+
+UString GetFolderPath(IFolderFolder *folder)
+{
+  {
+    NCOM::CPropVariant prop;
+    if (folder->GetFolderProperty(kpidPath, &prop) == S_OK)
+      if (prop.vt == VT_BSTR)
+        return (wchar_t *)prop.bstrVal;
+  }
+  return UString();
+}
+
+void CPanel::LoadFullPath()
+{
+  _currentFolderPrefix.Empty();
+  FOR_VECTOR (i, _parentFolders)
+  {
+    const CFolderLink &folderLink = _parentFolders[i];
+    _currentFolderPrefix += folderLink.ParentFolderPath;
+        // GetFolderPath(folderLink.ParentFolder);
+    _currentFolderPrefix += folderLink.RelPath;
+    _currentFolderPrefix.Add_PathSepar();
+  }
+  if (_folder)
+    _currentFolderPrefix += GetFolderPath(_folder);
+}
+
+static int GetRealIconIndex(CFSTR path, DWORD attributes)
+{
+  int index = -1;
+  if (GetRealIconIndex(path, attributes, index) != 0)
+    return index;
+  return -1;
+}
+
+void CPanel::LoadFullPathAndShow()
+{
+  LoadFullPath();
+  _appState->FolderHistory.AddString(_currentFolderPrefix);
+
+  _headerComboBox.SetText(_currentFolderPrefix);
+
+  #ifndef UNDER_CE
+
+  COMBOBOXEXITEM item;
+  item.mask = 0;
+
+  UString path = _currentFolderPrefix;
+  if (path.Len() >
+      #ifdef _WIN32
+      3
+      #else
+      1
+      #endif
+      && IS_PATH_SEPAR(path.Back()))
+    path.DeleteBack();
+
+  DWORD attrib = FILE_ATTRIBUTE_DIRECTORY;
+
+  // GetRealIconIndex is slow for direct DVD/UDF path. So we use dummy path
+  if (path.IsPrefixedBy(L"\\\\.\\"))
+    path = "_TestFolder_";
+  else
+  {
+    CFileInfo fi;
+    if (fi.Find(us2fs(path)))
+      attrib = fi.Attrib;
+  }
+  item.iImage = GetRealIconIndex(us2fs(path), attrib);
+
+  if (item.iImage >= 0)
+  {
+    item.iSelectedImage = item.iImage;
+    item.mask |= (CBEIF_IMAGE | CBEIF_SELECTEDIMAGE);
+  }
+  item.iItem = -1;
+  _headerComboBox.SetItem(&item);
+  
+  #endif
+
+  RefreshTitle();
+}
+
+#ifndef UNDER_CE
+LRESULT CPanel::OnNotifyComboBoxEnter(const UString &s)
+{
+  if (BindToPathAndRefresh(GetUnicodeString(s)) == S_OK)
+  {
+    PostMsg(kSetFocusToListView);
+    return TRUE;
+  }
+  return FALSE;
+}
+
+bool CPanel::OnNotifyComboBoxEndEdit(PNMCBEENDEDITW info, LRESULT &result)
+{
+  if (info->iWhy == CBENF_ESCAPE)
+  {
+    _headerComboBox.SetText(_currentFolderPrefix);
+    PostMsg(kSetFocusToListView);
+    result = FALSE;
+    return true;
+  }
+
+  /*
+  if (info->iWhy == CBENF_DROPDOWN)
+  {
+    result = FALSE;
+    return true;
+  }
+  */
+
+  if (info->iWhy == CBENF_RETURN)
+  {
+    // When we use Edit control and press Enter.
+    UString s;
+    _headerComboBox.GetText(s);
+    result = OnNotifyComboBoxEnter(s);
+    return true;
+  }
+  return false;
+}
+#endif
+
+#ifndef _UNICODE
+bool CPanel::OnNotifyComboBoxEndEdit(PNMCBEENDEDIT info, LRESULT &result)
+{
+  if (info->iWhy == CBENF_ESCAPE)
+  {
+    _headerComboBox.SetText(_currentFolderPrefix);
+    PostMsg(kSetFocusToListView);
+    result = FALSE;
+    return true;
+  }
+  /*
+  if (info->iWhy == CBENF_DROPDOWN)
+  {
+    result = FALSE;
+    return true;
+  }
+  */
+
+  if (info->iWhy == CBENF_RETURN)
+  {
+    UString s;
+    _headerComboBox.GetText(s);
+    // GetUnicodeString(info->szText)
+    result = OnNotifyComboBoxEnter(s);
+    return true;
+  }
+  return false;
+}
+#endif
+
+void CPanel::AddComboBoxItem(const UString &name, int iconIndex, int indent, bool addToList)
+{
+  #ifdef UNDER_CE
+
+  UString s;
+  iconIndex = iconIndex;
+  for (int i = 0; i < indent; i++)
+    s += "  ";
+  _headerComboBox.AddString(s + name);
+  
+  #else
+  
+  COMBOBOXEXITEMW item;
+  item.mask = CBEIF_TEXT | CBEIF_INDENT;
+  item.iSelectedImage = item.iImage = iconIndex;
+  if (iconIndex >= 0)
+    item.mask |= (CBEIF_IMAGE | CBEIF_SELECTEDIMAGE);
+  item.iItem = -1;
+  item.iIndent = indent;
+  item.pszText = name.Ptr_non_const();
+  _headerComboBox.InsertItem(&item);
+  
+  #endif
+
+  if (addToList)
+    ComboBoxPaths.Add(name);
+}
+
+extern UString RootFolder_GetName_Computer(int &iconIndex);
+extern UString RootFolder_GetName_Network(int &iconIndex);
+extern UString RootFolder_GetName_Documents(int &iconIndex);
+
+bool CPanel::OnComboBoxCommand(UINT code, LPARAM /* param */, LRESULT &result)
+{
+  result = FALSE;
+  switch (code)
+  {
+    case CBN_DROPDOWN:
+    {
+      ComboBoxPaths.Clear();
+      _headerComboBox.ResetContent();
+      
+      unsigned i;
+      UStringVector pathParts;
+      
+      SplitPathToParts(_currentFolderPrefix, pathParts);
+      UString sumPass;
+      if (!pathParts.IsEmpty())
+        pathParts.DeleteBack();
+      for (i = 0; i < pathParts.Size(); i++)
+      {
+        UString name = pathParts[i];
+        sumPass += name;
+        sumPass.Add_PathSepar();
+        CFileInfo info;
+        DWORD attrib = FILE_ATTRIBUTE_DIRECTORY;
+        if (info.Find(us2fs(sumPass)))
+          attrib = info.Attrib;
+        AddComboBoxItem(name.IsEmpty() ? L"\\" : name, GetRealIconIndex(us2fs(sumPass), attrib), i, false);
+        ComboBoxPaths.Add(sumPass);
+      }
+
+      #ifndef UNDER_CE
+
+      int iconIndex;
+      UString name;
+      name = RootFolder_GetName_Documents(iconIndex);
+      AddComboBoxItem(name, iconIndex, 0, true);
+
+      name = RootFolder_GetName_Computer(iconIndex);
+      AddComboBoxItem(name, iconIndex, 0, true);
+        
+      FStringVector driveStrings;
+      MyGetLogicalDriveStrings(driveStrings);
+      for (i = 0; i < driveStrings.Size(); i++)
+      {
+        FString s = driveStrings[i];
+        ComboBoxPaths.Add(fs2us(s));
+        int iconIndex2 = GetRealIconIndex(s, 0);
+        if (s.Len() > 0 && s.Back() == FCHAR_PATH_SEPARATOR)
+          s.DeleteBack();
+        AddComboBoxItem(fs2us(s), iconIndex2, 1, false);
+      }
+
+      name = RootFolder_GetName_Network(iconIndex);
+      AddComboBoxItem(name, iconIndex, 0, true);
+
+      #endif
+    
+      return false;
+    }
+
+    case CBN_SELENDOK:
+    {
+      int index = _headerComboBox.GetCurSel();
+      if (index >= 0)
+      {
+        UString pass = ComboBoxPaths[index];
+        _headerComboBox.SetCurSel(-1);
+        // _headerComboBox.SetText(pass); // it's fix for seclecting by mouse.
+        if (BindToPathAndRefresh(pass) == S_OK)
+        {
+          PostMsg(kSetFocusToListView);
+          #ifdef UNDER_CE
+          PostMsg(kRefresh_HeaderComboBox);
+          #endif
+          return true;
+        }
+      }
+      return false;
+    }
+    /*
+    case CBN_CLOSEUP:
+    {
+      LoadFullPathAndShow();
+      true;
+
+    }
+    case CBN_SELCHANGE:
+    {
+      // LoadFullPathAndShow();
+      return true;
+    }
+    */
+  }
+  return false;
+}
+
+bool CPanel::OnNotifyComboBox(LPNMHDR NON_CE_VAR(header), LRESULT & NON_CE_VAR(result))
+{
+  #ifndef UNDER_CE
+  switch (header->code)
+  {
+    case CBEN_BEGINEDIT:
+    {
+      _lastFocusedIsList = false;
+      _panelCallback->PanelWasFocused();
+      break;
+    }
+    #ifndef _UNICODE
+    case CBEN_ENDEDIT:
+    {
+      return OnNotifyComboBoxEndEdit((PNMCBEENDEDIT)header, result);
+    }
+    #endif
+    case CBEN_ENDEDITW:
+    {
+      return OnNotifyComboBoxEndEdit((PNMCBEENDEDITW)header, result);
+    }
+  }
+  #endif
+  return false;
+}
+
+
+void CPanel::FoldersHistory()
+{
+  CListViewDialog listViewDialog;
+  listViewDialog.DeleteIsAllowed = true;
+  listViewDialog.SelectFirst = true;
+  LangString(IDS_FOLDERS_HISTORY, listViewDialog.Title);
+  _appState->FolderHistory.GetList(listViewDialog.Strings);
+  if (listViewDialog.Create(GetParent()) != IDOK)
+    return;
+  UString selectString;
+  if (listViewDialog.StringsWereChanged)
+  {
+    _appState->FolderHistory.RemoveAll();
+    for (int i = listViewDialog.Strings.Size() - 1; i >= 0; i--)
+      _appState->FolderHistory.AddString(listViewDialog.Strings[i]);
+    if (listViewDialog.FocusedItemIndex >= 0)
+      selectString = listViewDialog.Strings[listViewDialog.FocusedItemIndex];
+  }
+  else
+  {
+    if (listViewDialog.FocusedItemIndex >= 0)
+      selectString = listViewDialog.Strings[listViewDialog.FocusedItemIndex];
+  }
+  if (listViewDialog.FocusedItemIndex >= 0)
+    BindToPathAndRefresh(selectString);
+}
+
+
+UString CPanel::GetParentDirPrefix() const
+{
+  UString s;
+  if (!_currentFolderPrefix.IsEmpty())
+  {
+    wchar_t c = _currentFolderPrefix.Back();
+    if (IS_PATH_SEPAR(c) || c == ':')
+    {
+      s = _currentFolderPrefix;
+      s.DeleteBack();
+      if (s != L"\\\\." &&
+          s != L"\\\\?")
+      {
+        int pos = s.ReverseFind_PathSepar();
+        if (pos >= 0)
+          s.DeleteFrom((unsigned)(pos + 1));
+      }
+    }
+  }
+  return s;
+}
+
+
+void CPanel::OpenParentFolder()
+{
+  LoadFullPath(); // Maybe we don't need it ??
+  
+  UString parentFolderPrefix;
+  UString focusedName;
+  
+  if (!_currentFolderPrefix.IsEmpty())
+  {
+    wchar_t c = _currentFolderPrefix.Back();
+    if (IS_PATH_SEPAR(c) || c == ':')
+    {
+      focusedName = _currentFolderPrefix;
+      focusedName.DeleteBack();
+      /*
+      if (c == ':' && !focusedName.IsEmpty() && IS_PATH_SEPAR(focusedName.Back()))
+      {
+        focusedName.DeleteBack();
+      }
+      else
+      */
+      if (focusedName != L"\\\\." &&
+          focusedName != L"\\\\?")
+      {
+        int pos = focusedName.ReverseFind_PathSepar();
+        if (pos >= 0)
+        {
+          parentFolderPrefix = focusedName;
+          parentFolderPrefix.DeleteFrom((unsigned)(pos + 1));
+          focusedName.DeleteFrontal(pos + 1);
+        }
+      }
+    }
+  }
+
+  CDisableTimerProcessing disableTimerProcessing(*this);
+  CDisableNotify disableNotify(*this);
+  
+  CMyComPtr<IFolderFolder> newFolder;
+  _folder->BindToParentFolder(&newFolder);
+
+  // newFolder.Release(); // for test
+  
+  if (newFolder)
+    SetNewFolder(newFolder);
+  else
+  {
+    bool needSetFolder = true;
+    if (!_parentFolders.IsEmpty())
+    {
+      {
+        const CFolderLink &link = _parentFolders.Back();
+        parentFolderPrefix = link.ParentFolderPath;
+        focusedName = link.RelPath;
+      }
+      CloseOneLevel();
+      needSetFolder = (!_folder);
+    }
+    
+    if (needSetFolder)
+    {
+      {
+        COpenResult openRes;
+        BindToPath(parentFolderPrefix, UString(), openRes);
+      }
+    }
+  }
+    
+  CSelectedState state;
+  state.FocusedName = focusedName;
+  state.FocusedName_Defined = true;
+  /*
+  if (!focusedName.IsEmpty())
+    state.SelectedNames.Add(focusedName);
+  */
+  LoadFullPath();
+  // ::SetCurrentDirectory(::_currentFolderPrefix);
+  RefreshListCtrl(state);
+  // _listView.EnsureVisible(_listView.GetFocusedItem(), false);
+}
+
+
+void CPanel::CloseOneLevel()
+{
+  ReleaseFolder();
+  _library.Free();
+  {
+    CFolderLink &link = _parentFolders.Back();
+    if (link.ParentFolder)
+      SetNewFolder(link.ParentFolder);
+    _library.Attach(link.Library.Detach());
+  }
+  if (_parentFolders.Size() > 1)
+    OpenParentArchiveFolder();
+  _parentFolders.DeleteBack();
+  if (_parentFolders.IsEmpty())
+    _flatMode = _flatModeForDisk;
+}
+
+void CPanel::CloseOpenFolders()
+{
+  while (!_parentFolders.IsEmpty())
+    CloseOneLevel();
+  _flatMode = _flatModeForDisk;
+  ReleaseFolder();
+  _library.Free();
+}
+
+void CPanel::OpenRootFolder()
+{
+  CDisableTimerProcessing disableTimerProcessing(*this);
+  CDisableNotify disableNotify(*this);
+  _parentFolders.Clear();
+  SetToRootFolder();
+  RefreshListCtrl();
+  // ::SetCurrentDirectory(::_currentFolderPrefix);
+  /*
+  BeforeChangeFolder();
+  _currentFolderPrefix.Empty();
+  AfterChangeFolder();
+  SetCurrentPathText();
+  RefreshListCtrl(UString(), 0, UStringVector());
+  _listView.EnsureVisible(_listView.GetFocusedItem(), false);
+  */
+}
+
+void CPanel::OpenDrivesFolder()
+{
+  CloseOpenFolders();
+  #ifdef UNDER_CE
+  NFsFolder::CFSFolder *folderSpec = new NFsFolder::CFSFolder;
+  SetNewFolder(folderSpec);
+  folderSpec->InitToRoot();
+  #else
+  CFSDrives *folderSpec = new CFSDrives;
+  SetNewFolder(folderSpec);
+  folderSpec->Init();
+  #endif
+  RefreshListCtrl();
+}
+
+void CPanel::OpenFolder(int index)
+{
+  if (index == kParentIndex)
+  {
+    OpenParentFolder();
+    return;
+  }
+  CMyComPtr<IFolderFolder> newFolder;
+  HRESULT res = _folder->BindToFolder(index, &newFolder);
+  if (res != 0)
+  {
+    MessageBox_Error_HRESULT(res);
+    return;
+  }
+  if (!newFolder)
+    return;
+  SetNewFolder(newFolder);
+  LoadFullPath();
+  RefreshListCtrl();
+  // 17.02: fixed : now we don't select first item
+  // _listView.SetItemState_Selected(_listView.GetFocusedItem());
+  _listView.EnsureVisible(_listView.GetFocusedItem(), false);
+}
+
+void CPanel::OpenAltStreams()
+{
+  CRecordVector<UInt32> indices;
+  GetOperatedItemIndices(indices);
+  Int32 realIndex = -1;
+  if (indices.Size() > 1)
+    return;
+  if (indices.Size() == 1)
+    realIndex = indices[0];
+
+  if (_folderAltStreams)
+  {
+    CMyComPtr<IFolderFolder> newFolder;
+    _folderAltStreams->BindToAltStreams(realIndex, &newFolder);
+    if (newFolder)
+    {
+      CDisableTimerProcessing disableTimerProcessing(*this);
+      CDisableNotify disableNotify(*this);
+      SetNewFolder(newFolder);
+      RefreshListCtrl();
+      return;
+    }
+    return;
+  }
+  
+  #if defined(_WIN32) && !defined(UNDER_CE)
+  UString path;
+  if (realIndex >= 0)
+    path = GetItemFullPath(realIndex);
+  else
+  {
+    path = GetFsPath();
+    if (!NName::IsDriveRootPath_SuperAllowed(us2fs(path)))
+      if (!path.IsEmpty() && IS_PATH_SEPAR(path.Back()))
+        path.DeleteBack();
+  }
+
+  path += ':';
+  BindToPathAndRefresh(path);
+  #endif
+}
diff --git a/CPP/7zip/UI/FileManager/PanelItemOpen.cpp b/CPP/7zip/UI/FileManager/PanelItemOpen.cpp
new file mode 100644
index 0000000..ba54491
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelItemOpen.cpp
@@ -0,0 +1,1874 @@
+// PanelItemOpen.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyWindows.h"
+
+#include <TlHelp32.h>
+
+#include "../../../Common/IntToString.h"
+
+#include "../../../Common/AutoPtr.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/ProcessUtils.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#include "../../Common/FileStreams.h"
+#include "../../Common/StreamObjects.h"
+
+#include "../Common/ExtractingFilePath.h"
+
+#include "App.h"
+
+#include "FileFolderPluginOpen.h"
+#include "FormatUtils.h"
+#include "LangUtils.h"
+#include "PropertyNameRes.h"
+#include "RegistryUtils.h"
+#include "UpdateCallback100.h"
+
+#include "../GUI/ExtractRes.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+using namespace NSynchronization;
+using namespace NFile;
+using namespace NDir;
+
+extern bool g_RAM_Size_Defined;
+extern UInt64 g_RAM_Size;
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+#define kTempDirPrefix FTEXT("7zO")
+
+// #define SHOW_DEBUG_INFO
+
+#ifdef SHOW_DEBUG_INFO
+  #define DEBUG_PRINT(s) OutputDebugStringA(s);
+  #define DEBUG_PRINT_W(s) OutputDebugStringW(s);
+  #define DEBUG_PRINT_NUM(s, num) { char ttt[32]; ConvertUInt32ToString(num, ttt); OutputDebugStringA(s); OutputDebugStringA(ttt); }
+#else
+  #define DEBUG_PRINT(s)
+  #define DEBUG_PRINT_W(s)
+  #define DEBUG_PRINT_NUM(s, num)
+#endif
+
+
+
+#ifndef UNDER_CE
+
+class CProcessSnapshot
+{
+  HANDLE _handle;
+public:
+  CProcessSnapshot(): _handle(INVALID_HANDLE_VALUE) {};
+  ~CProcessSnapshot() { Close(); }
+
+  bool Close()
+  {
+    if (_handle == INVALID_HANDLE_VALUE)
+      return true;
+    if (!::CloseHandle(_handle))
+      return false;
+    _handle = INVALID_HANDLE_VALUE;
+    return true;
+  }
+
+  bool Create()
+  {
+    _handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+    return (_handle != INVALID_HANDLE_VALUE);
+  }
+
+  bool GetFirstProcess(PROCESSENTRY32 *pe) { return BOOLToBool(Process32First(_handle, pe)); }
+  bool GetNextProcess(PROCESSENTRY32 *pe) { return BOOLToBool(Process32Next(_handle, pe)); }
+};
+
+#endif
+
+
+/*
+struct COpenExtProg
+{
+  const char *Ext;
+  const char *Prog;
+};
+
+static const COpenExtProg g_Progs[] =
+{
+  { "jpeg jpg png bmp gif", "Microsoft.Photos.exe" },
+  { "html htm pdf", "MicrosoftEdge.exe" },
+  // , { "rrr", "notepad.exe" }
+};
+
+static bool FindExtProg(const char *exts, const char *ext)
+{
+  unsigned len = (unsigned)strlen(ext);
+  for (;;)
+  {
+    const char *p = exts;
+    for (;; p++)
+    {
+      const char c = *p;
+      if (c == 0 || c == ' ')
+        break;
+    }
+    if (len == (unsigned)(p - exts) && IsString1PrefixedByString2(exts, ext))
+      return true;
+    if (*p == 0)
+      return false;
+    exts = p + 1;
+  }
+}
+
+class CPossibleProgs
+{
+public:
+  AStringVector ProgNames;
+
+  void SetFromExtension(const char *ext) // ext must be low case
+  {
+    ProgNames.Clear();
+    for (unsigned i = 0; i < ARRAY_SIZE(g_Progs); i++)
+      if (FindExtProg(g_Progs[i].Ext, ext))
+      {
+        ProgNames.Add(g_Progs[i].Prog);
+      }
+  }
+  
+  bool IsFromList(const UString &progName) const
+  {
+    FOR_VECTOR (i, ProgNames)
+      if (progName.IsEqualTo_Ascii_NoCase(ProgNames[i]))
+        return true;
+    return false;
+  }
+};
+*/
+
+
+#ifndef UNDER_CE
+
+EXTERN_C_BEGIN
+
+/*
+GetProcessImageFileName
+  returns the path in device form, rather than drive letters:
+    \Device\HarddiskVolume1\WINDOWS\SysWOW64\notepad.exe
+
+GetModuleFileNameEx works only after Sleep(something). Why?
+  returns the path
+    C:\WINDOWS\system32\NOTEPAD.EXE
+*/
+
+/* Kernel32.dll: Win7, Win2008R2;
+   Psapi.dll: (if PSAPI_VERSION=1) on Win7 and Win2008R2;
+   Psapi.dll: XP, Win2003, Vista, 2008;
+*/
+
+typedef DWORD (WINAPI *Func_GetProcessImageFileNameW)(
+    HANDLE hProcess, LPWSTR lpFilename, DWORD nSize);
+
+typedef DWORD (WINAPI *Func_GetModuleFileNameExW)(
+    HANDLE hProcess, HMODULE hModule, LPWSTR lpFilename, DWORD nSize);
+
+typedef DWORD (WINAPI *Func_GetProcessId)(HANDLE process);
+
+EXTERN_C_END
+
+
+static HMODULE g_Psapi_dll_module;
+
+/*
+static void My_GetProcessFileName_2(HANDLE hProcess, UString &path)
+{
+  path.Empty();
+  const unsigned maxPath = 1024;
+  WCHAR temp[maxPath + 1];
+  
+  const char *func_name = "GetModuleFileNameExW";
+  Func_GetModuleFileNameExW my_func = (Func_GetModuleFileNameExW)
+    ::GetProcAddress(::GetModuleHandleA("kernel32.dll"), func_name);
+  if (!my_func)
+  {
+    if (!g_Psapi_dll_module)
+      g_Psapi_dll_module = LoadLibraryW(L"Psapi.dll");
+    if (g_Psapi_dll_module)
+      my_func = (Func_GetModuleFileNameExW)::GetProcAddress(g_Psapi_dll_module, func_name);
+  }
+  if (my_func)
+  {
+    // DWORD num = GetModuleFileNameEx(hProcess, NULL, temp, maxPath);
+    DWORD num = my_func(hProcess, NULL, temp, maxPath);
+    if (num != 0)
+      path = temp;
+  }
+  // FreeLibrary(lib);
+}
+*/
+
+static void My_GetProcessFileName(HANDLE hProcess, UString &path)
+{
+  path.Empty();
+  const unsigned maxPath = 1024;
+  WCHAR temp[maxPath + 1];
+  
+  const char *func_name = "GetProcessImageFileNameW";
+  Func_GetProcessImageFileNameW my_func = (Func_GetProcessImageFileNameW)
+    (void *)::GetProcAddress(::GetModuleHandleA("kernel32.dll"), func_name);
+  
+  if (!my_func)
+  {
+    if (!g_Psapi_dll_module)
+      g_Psapi_dll_module = LoadLibraryW(L"Psapi.dll");
+    if (g_Psapi_dll_module)
+      my_func = (Func_GetProcessImageFileNameW)(void *)::GetProcAddress(g_Psapi_dll_module, func_name);
+  }
+  
+  if (my_func)
+  {
+    // DWORD num = GetProcessImageFileNameW(hProcess, temp, maxPath);
+    DWORD num = my_func(hProcess, temp, maxPath);
+    if (num != 0)
+      path = temp;
+  }
+  // FreeLibrary(lib);
+}
+
+struct CSnapshotProcess
+{
+  DWORD Id;
+  DWORD ParentId;
+  UString Name;
+};
+
+static void GetSnapshot(CObjectVector<CSnapshotProcess> &items)
+{
+  items.Clear();
+
+  CProcessSnapshot snapshot;
+  if (!snapshot.Create())
+    return;
+
+  DEBUG_PRINT("snapshot.Create() OK");
+  PROCESSENTRY32 pe;
+  CSnapshotProcess item;
+  memset(&pe, 0, sizeof(pe));
+  pe.dwSize = sizeof(pe);
+  BOOL res = snapshot.GetFirstProcess(&pe);
+  while (res)
+  {
+    item.Id = pe.th32ProcessID;
+    item.ParentId = pe.th32ParentProcessID;
+    item.Name = GetUnicodeString(pe.szExeFile);
+    items.Add(item);
+    res = snapshot.GetNextProcess(&pe);
+  }
+}
+
+#endif
+
+
+class CChildProcesses
+{
+  #ifndef UNDER_CE
+  CRecordVector<DWORD> _ids;
+  #endif
+
+public:
+  // bool ProgsWereUsed;
+  CRecordVector<HANDLE> Handles;
+  CRecordVector<bool> NeedWait;
+  // UStringVector Names;
+
+  #ifndef UNDER_CE
+  UString Path;
+  #endif
+
+  // CChildProcesses(): ProgsWereUsed(false) {}
+  ~CChildProcesses() { CloseAll(); }
+  void DisableWait(unsigned index) { NeedWait[index] = false; }
+  
+  void CloseAll()
+  {
+    FOR_VECTOR (i, Handles)
+    {
+      HANDLE h = Handles[i];
+      if (h != NULL)
+        CloseHandle(h);
+    }
+
+    Handles.Clear();
+    NeedWait.Clear();
+    // Names.Clear();
+
+    #ifndef UNDER_CE
+    // Path.Empty();
+    _ids.Clear();
+    #endif
+  }
+
+  void SetMainProcess(HANDLE h)
+  {
+    #ifndef UNDER_CE
+
+    Func_GetProcessId func = (Func_GetProcessId)(void *)::GetProcAddress(::GetModuleHandleA("kernel32.dll"), "GetProcessId");
+    if (func)
+    {
+      DWORD id = func(h);
+      if (id != 0)
+        _ids.AddToUniqueSorted(id);
+    }
+    
+    My_GetProcessFileName(h, Path);
+    DEBUG_PRINT_W(Path);
+
+    #endif
+
+    Handles.Add(h);
+    NeedWait.Add(true);
+  }
+
+  #ifndef UNDER_CE
+
+  void Update(bool needFindProcessByPath /* , const CPossibleProgs &progs */)
+  {
+    /*
+    if (_ids.IsEmpty())
+      return;
+    */
+
+    CObjectVector<CSnapshotProcess> sps;
+    GetSnapshot(sps);
+
+    const int separ = Path.ReverseFind_PathSepar();
+    const UString mainName = Path.Ptr((unsigned)(separ + 1));
+    if (mainName.IsEmpty())
+      needFindProcessByPath = false;
+
+    const DWORD currentProcessId = GetCurrentProcessId();
+
+    for (;;)
+    {
+      bool wasAdded = false;
+      
+      FOR_VECTOR (i, sps)
+      {
+        const CSnapshotProcess &sp = sps[i];
+        const DWORD id = sp.Id;
+        
+        if (id == currentProcessId)
+          continue;
+        if (_ids.FindInSorted(id) >= 0)
+          continue;
+
+        bool isSameName = false;
+        const UString &name = sp.Name;
+        
+        if (needFindProcessByPath)
+          isSameName = mainName.IsEqualTo_NoCase(name);
+
+        bool needAdd = false;
+        // bool isFromProgs = false;
+        
+        if (isSameName || _ids.FindInSorted(sp.ParentId) >= 0)
+          needAdd = true;
+        /*
+        else if (progs.IsFromList(name))
+        {
+          needAdd = true;
+          isFromProgs = true;
+        }
+        */
+
+        if (needAdd)
+        {
+          DEBUG_PRINT("----- OpenProcess -----");
+          DEBUG_PRINT_W(name);
+          HANDLE hProcess = OpenProcess(SYNCHRONIZE, FALSE, id);
+          if (hProcess)
+          {
+            DEBUG_PRINT("----- OpenProcess OK -----");
+            // if (!isFromProgs)
+              _ids.AddToUniqueSorted(id);
+            Handles.Add(hProcess);
+            NeedWait.Add(true);
+            // Names.Add(name);
+            wasAdded = true;
+            // ProgsWereUsed = isFromProgs;
+          }
+        }
+      }
+      
+      if (!wasAdded)
+        break;
+    }
+  }
+  
+  #endif
+};
+
+
+struct CTmpProcessInfo: public CTempFileInfo
+{
+  CChildProcesses Processes;
+  HWND Window;
+  UString FullPathFolderPrefix;
+  bool UsePassword;
+  UString Password;
+
+  bool ReadOnly;
+  
+  CTmpProcessInfo(): UsePassword(false), ReadOnly(false) {}
+};
+
+
+class CTmpProcessInfoRelease
+{
+  CTmpProcessInfo *_tmpProcessInfo;
+public:
+  bool _needDelete;
+  CTmpProcessInfoRelease(CTmpProcessInfo &tpi):
+      _tmpProcessInfo(&tpi), _needDelete(true) {}
+  ~CTmpProcessInfoRelease()
+  {
+    if (_needDelete)
+      _tmpProcessInfo->DeleteDirAndFile();
+  }
+};
+
+void GetFolderError(CMyComPtr<IFolderFolder> &folder, UString &s);
+
+
+HRESULT CPanel::OpenAsArc(IInStream *inStream,
+    const CTempFileInfo &tempFileInfo,
+    const UString &virtualFilePath,
+    const UString &arcFormat,
+    COpenResult &openRes)
+{
+  openRes.Encrypted = false;
+  CFolderLink folderLink;
+  (CTempFileInfo &)folderLink = tempFileInfo;
+  
+  if (inStream)
+    folderLink.IsVirtual = true;
+  else
+  {
+    if (!folderLink.FileInfo.Find(folderLink.FilePath))
+      return ::GetLastError();
+    if (folderLink.FileInfo.IsDir())
+      return S_FALSE;
+    folderLink.IsVirtual = false;
+  }
+
+  folderLink.VirtualPath = virtualFilePath;
+
+  CFfpOpen ffp;
+  HRESULT res = ffp.OpenFileFolderPlugin(inStream,
+      folderLink.FilePath.IsEmpty() ? us2fs(virtualFilePath) : folderLink.FilePath,
+      arcFormat, GetParent());
+
+  openRes.Encrypted = ffp.Encrypted;
+  openRes.ErrorMessage = ffp.ErrorMessage;
+
+  RINOK(res);
+ 
+  folderLink.Password = ffp.Password;
+  folderLink.UsePassword = ffp.Encrypted;
+
+  if (_folder)
+    folderLink.ParentFolderPath = GetFolderPath(_folder);
+  else
+    folderLink.ParentFolderPath = _currentFolderPrefix;
+  
+  if (!_parentFolders.IsEmpty())
+    folderLink.ParentFolder = _folder;
+
+  _parentFolders.Add(folderLink);
+  _parentFolders.Back().Library.Attach(_library.Detach());
+
+  ReleaseFolder();
+  _library.Free();
+  SetNewFolder(ffp.Folder);
+  _library.Attach(ffp.Library.Detach());
+
+  _flatMode = _flatModeForArc;
+
+  _thereAreDeletedItems = false;
+  
+  if (!openRes.ErrorMessage.IsEmpty())
+    MessageBox_Error(openRes.ErrorMessage);
+  /*
+  UString s;
+  GetFolderError(_folder, s);
+  if (!s.IsEmpty())
+    MessageBox_Error(s);
+  */
+  // we don't show error here by some reasons:
+  // after MessageBox_Warning it throws exception in nested archives in Debug Mode. why ?.
+  // MessageBox_Warning(L"test error");
+
+  return S_OK;
+}
+
+
+HRESULT CPanel::OpenAsArc_Msg(IInStream *inStream,
+    const CTempFileInfo &tempFileInfo,
+    const UString &virtualFilePath,
+    const UString &arcFormat
+    // , bool &encrypted
+    // , bool showErrorMessage
+    )
+{
+  COpenResult opRes;
+
+  HRESULT res = OpenAsArc(inStream, tempFileInfo, virtualFilePath, arcFormat, opRes);
+  
+  if (res == S_OK)
+    return res;
+  if (res == E_ABORT)
+    return res;
+
+  // if (showErrorMessage)
+  if (opRes.Encrypted || res != S_FALSE) // 17.01 : we show message also for (res != S_FALSE)
+  {
+    UString message;
+    if (res == S_FALSE)
+    {
+      message = MyFormatNew(
+          opRes.Encrypted ?
+            IDS_CANT_OPEN_ENCRYPTED_ARCHIVE :
+            IDS_CANT_OPEN_ARCHIVE,
+          virtualFilePath);
+    }
+    else
+      message = HResultToMessage(res);
+    MessageBox_Error(message);
+  }
+
+  return res;
+}
+
+
+HRESULT CPanel::OpenAsArc_Name(const UString &relPath, const UString &arcFormat
+    // , bool &encrypted,
+    // , bool showErrorMessage
+    )
+{
+  CTempFileInfo tfi;
+  tfi.RelPath = relPath;
+  tfi.FolderPath = us2fs(GetFsPath());
+  const UString fullPath = GetFsPath() + relPath;
+  tfi.FilePath = us2fs(fullPath);
+  return OpenAsArc_Msg(NULL, tfi, fullPath, arcFormat /* , encrypted, showErrorMessage */);
+}
+
+
+HRESULT CPanel::OpenAsArc_Index(int index, const wchar_t *type
+    // , bool showErrorMessage
+    )
+{
+  CDisableTimerProcessing disableTimerProcessing1(*this);
+  CDisableNotify disableNotify(*this);
+
+  HRESULT res = OpenAsArc_Name(GetItemRelPath2(index), type ? type : L"" /* , encrypted, showErrorMessage */);
+  if (res != S_OK)
+  {
+    RefreshTitle(true); // in case of error we must refresh changed title of 7zFM
+    return res;
+  }
+  RefreshListCtrl();
+  return S_OK;
+}
+
+
+HRESULT CPanel::OpenParentArchiveFolder()
+{
+  CDisableTimerProcessing disableTimerProcessing(*this);
+  CDisableNotify disableNotify(*this);
+  if (_parentFolders.Size() < 2)
+    return S_OK;
+  const CFolderLink &folderLinkPrev = _parentFolders[_parentFolders.Size() - 2];
+  const CFolderLink &folderLink = _parentFolders.Back();
+  NFind::CFileInfo newFileInfo;
+  if (newFileInfo.Find(folderLink.FilePath))
+  {
+    if (folderLink.WasChanged(newFileInfo))
+    {
+      UString message = MyFormatNew(IDS_WANT_UPDATE_MODIFIED_FILE, folderLink.RelPath);
+      if (::MessageBoxW((HWND)*this, message, L"7-Zip", MB_OKCANCEL | MB_ICONQUESTION) == IDOK)
+      {
+        if (OnOpenItemChanged(folderLink.FileIndex, fs2us(folderLink.FilePath),
+            folderLinkPrev.UsePassword, folderLinkPrev.Password) != S_OK)
+        {
+          ::MessageBoxW((HWND)*this, MyFormatNew(IDS_CANNOT_UPDATE_FILE,
+              fs2us(folderLink.FilePath)), L"7-Zip", MB_OK | MB_ICONSTOP);
+          return S_OK;
+        }
+      }
+    }
+  }
+  folderLink.DeleteDirAndFile();
+  return S_OK;
+}
+
+
+static const char * const kExeExtensions =
+  " exe bat ps1 com"
+  " ";
+
+static const char * const kStartExtensions =
+  #ifdef UNDER_CE
+  " cab"
+  #endif
+  " exe bat ps1 com"
+  " chm"
+  " msi doc dot xls ppt pps wps wpt wks xlr wdb vsd pub"
+
+  " docx docm dotx dotm xlsx xlsm xltx xltm xlsb xps"
+  " xlam pptx pptm potx potm ppam ppsx ppsm vsdx xsn"
+  " mpp"
+  " msg"
+  " dwf"
+
+  " flv swf"
+  
+  " epub"
+  " odt ods"
+  " wb3"
+  " pdf"
+  " ps"
+  " txt"
+  " xml xsd xsl xslt hxk hxc htm html xhtml xht mht mhtml htw asp aspx css cgi jsp shtml"
+  " h hpp hxx c cpp cxx m mm go swift"
+  " awk sed hta js json php php3 php4 php5 phptml pl pm py pyo rb tcl ts vbs"
+  " asm"
+  " mak clw csproj vcproj sln dsp dsw"
+  " ";
+
+static bool FindExt(const char *p, const UString &name)
+{
+  int dotPos = name.ReverseFind_Dot();
+  if (dotPos < 0 || dotPos == (int)name.Len() - 1)
+    return false;
+
+  AString s;
+  for (unsigned pos = dotPos + 1;; pos++)
+  {
+    wchar_t c = name[pos];
+    if (c == 0)
+      break;
+    if (c >= 0x80)
+      return false;
+    s += (char)MyCharLower_Ascii((char)c);
+  }
+  for (unsigned i = 0; p[i] != 0;)
+  {
+    unsigned j;
+    for (j = i; p[j] != ' '; j++);
+    if (s.Len() == j - i && memcmp(p + i, (const char *)s, s.Len()) == 0)
+      return true;
+    i = j + 1;
+  }
+  return false;
+}
+
+static bool DoItemAlwaysStart(const UString &name)
+{
+  return FindExt(kStartExtensions, name);
+}
+
+UString GetQuotedString(const UString &s);
+
+
+void SplitCmdLineSmart(const UString &cmd, UString &prg, UString &params);
+void SplitCmdLineSmart(const UString &cmd, UString &prg, UString &params)
+{
+  params.Empty();
+  prg = cmd;
+  prg.Trim();
+  if (prg.Len() >= 2 && prg[0] == L'"')
+  {
+    int pos = prg.Find(L'"', 1);
+    if (pos >= 0)
+    {
+      if ((unsigned)(pos + 1) == prg.Len() || prg[pos + 1] == ' ')
+      {
+        params = prg.Ptr((unsigned)(pos + 1));
+        params.Trim();
+        prg.DeleteFrom((unsigned)pos);
+        prg.DeleteFrontal(1);
+      }
+    }
+  }
+}
+
+
+static WRes StartAppWithParams(const UString &cmd, const UStringVector &paramVector, CProcess &process)
+{
+  UString param;
+  UString prg;
+
+  SplitCmdLineSmart(cmd, prg, param);
+  
+  param.Trim();
+
+  // int pos = params.Find(L"%1");
+
+  FOR_VECTOR (i, paramVector)
+  {
+    if (!param.IsEmpty() && param.Back() != ' ')
+      param.Add_Space();
+    param += GetQuotedString(paramVector[i]);
+  }
+  
+  return process.Create(prg, param, NULL);
+}
+
+
+static HRESULT StartEditApplication(const UString &path, bool useEditor, HWND window, CProcess &process)
+{
+  UString command;
+  ReadRegEditor(useEditor, command);
+  if (command.IsEmpty())
+  {
+    #ifdef UNDER_CE
+    command = "\\Windows\\";
+    #else
+    FString winDir;
+    if (!GetWindowsDir(winDir))
+      return 0;
+    NName::NormalizeDirPathPrefix(winDir);
+    command = fs2us(winDir);
+    #endif
+    command += "notepad.exe";
+  }
+
+  UStringVector params;
+  params.Add(path);
+
+  HRESULT res = StartAppWithParams(command, params, process);
+  if (res != SZ_OK)
+    ::MessageBoxW(window, LangString(IDS_CANNOT_START_EDITOR), L"7-Zip", MB_OK  | MB_ICONSTOP);
+  return res;
+}
+
+
+void CApp::DiffFiles()
+{
+  const CPanel &panel = GetFocusedPanel();
+  
+  if (!panel.Is_IO_FS_Folder())
+  {
+    panel.MessageBox_Error_UnsupportOperation();
+    return;
+  }
+
+  CRecordVector<UInt32> indices;
+  panel.GetSelectedItemsIndices(indices);
+
+  UString path1, path2;
+  if (indices.Size() == 2)
+  {
+    path1 = panel.GetItemFullPath(indices[0]);
+    path2 = panel.GetItemFullPath(indices[1]);
+  }
+  else if (indices.Size() == 1 && NumPanels >= 2)
+  {
+    const CPanel &destPanel = Panels[1 - LastFocusedPanel];
+
+    if (!destPanel.Is_IO_FS_Folder())
+    {
+      panel.MessageBox_Error_UnsupportOperation();
+      return;
+    }
+
+    path1 = panel.GetItemFullPath(indices[0]);
+    CRecordVector<UInt32> indices2;
+    destPanel.GetSelectedItemsIndices(indices2);
+    if (indices2.Size() == 1)
+      path2 = destPanel.GetItemFullPath(indices2[0]);
+    else
+    {
+      UString relPath = panel.GetItemRelPath2(indices[0]);
+      if (panel._flatMode && !destPanel._flatMode)
+        relPath = panel.GetItemName(indices[0]);
+      path2 = destPanel._currentFolderPrefix + relPath;
+    }
+  }
+  else
+    return;
+
+  DiffFiles(path1, path2);
+}
+
+void CApp::DiffFiles(const UString &path1, const UString &path2)
+{
+  UString command;
+  ReadRegDiff(command);
+  if (command.IsEmpty())
+    return;
+
+  UStringVector params;
+  params.Add(path1);
+  params.Add(path2);
+
+  HRESULT res;
+  {
+    CProcess process;
+    res = StartAppWithParams(command, params, process);
+  }
+  if (res == SZ_OK)
+    return;
+  ::MessageBoxW(_window, LangString(IDS_CANNOT_START_EDITOR), L"7-Zip", MB_OK  | MB_ICONSTOP);
+}
+
+
+#ifndef _UNICODE
+typedef BOOL (WINAPI * ShellExecuteExWP)(LPSHELLEXECUTEINFOW lpExecInfo);
+#endif
+
+static HRESULT StartApplication(const UString &dir, const UString &path, HWND window, CProcess &process)
+{
+  UString path2 = path;
+
+  #ifdef _WIN32
+  {
+    int dot = path2.ReverseFind_Dot();
+    int separ = path2.ReverseFind_PathSepar();
+    if (dot < 0 || dot < separ)
+      path2 += '.';
+  }
+  #endif
+
+  UINT32 result;
+  
+  #ifndef _UNICODE
+  if (g_IsNT)
+  {
+    SHELLEXECUTEINFOW execInfo;
+    execInfo.cbSize = sizeof(execInfo);
+    execInfo.fMask = SEE_MASK_NOCLOSEPROCESS | SEE_MASK_FLAG_DDEWAIT;
+    execInfo.hwnd = NULL;
+    execInfo.lpVerb = NULL;
+    execInfo.lpFile = path2;
+    execInfo.lpParameters = NULL;
+    execInfo.lpDirectory = dir.IsEmpty() ? NULL : (LPCWSTR)dir;
+    execInfo.nShow = SW_SHOWNORMAL;
+    execInfo.hProcess = 0;
+    ShellExecuteExWP shellExecuteExW = (ShellExecuteExWP)
+    (void *)::GetProcAddress(::GetModuleHandleW(L"shell32.dll"), "ShellExecuteExW");
+    if (!shellExecuteExW)
+      return 0;
+    shellExecuteExW(&execInfo);
+    result = (UINT32)(UINT_PTR)execInfo.hInstApp;
+    process.Attach(execInfo.hProcess);
+  }
+  else
+  #endif
+  {
+    SHELLEXECUTEINFO execInfo;
+    execInfo.cbSize = sizeof(execInfo);
+    execInfo.fMask = SEE_MASK_NOCLOSEPROCESS
+      #ifndef UNDER_CE
+      | SEE_MASK_FLAG_DDEWAIT
+      #endif
+      ;
+    execInfo.hwnd = NULL;
+    execInfo.lpVerb = NULL;
+    const CSysString sysPath (GetSystemString(path2));
+    const CSysString sysDir (GetSystemString(dir));
+    execInfo.lpFile = sysPath;
+    execInfo.lpParameters = NULL;
+    execInfo.lpDirectory =
+      #ifdef UNDER_CE
+        NULL
+      #else
+        sysDir.IsEmpty() ? NULL : (LPCTSTR)sysDir
+      #endif
+      ;
+    execInfo.nShow = SW_SHOWNORMAL;
+    execInfo.hProcess = 0;
+    ::ShellExecuteEx(&execInfo);
+    result = (UINT32)(UINT_PTR)execInfo.hInstApp;
+    process.Attach(execInfo.hProcess);
+  }
+  
+
+  DEBUG_PRINT_NUM("-- ShellExecuteEx -- execInfo.hInstApp = ", result)
+
+  if (result <= 32)
+  {
+    switch (result)
+    {
+      case SE_ERR_NOASSOC:
+        ::MessageBoxW(window,
+          NError::MyFormatMessage(::GetLastError()),
+          // L"There is no application associated with the given file name extension",
+          L"7-Zip", MB_OK | MB_ICONSTOP);
+    }
+    
+    return E_FAIL; // fixed in 15.13. Can we use it for any Windows version?
+  }
+  
+  return S_OK;
+}
+
+static void StartApplicationDontWait(const UString &dir, const UString &path, HWND window)
+{
+  CProcess process;
+  StartApplication(dir, path, window, process);
+}
+
+void CPanel::EditItem(int index, bool useEditor)
+{
+  if (!_parentFolders.IsEmpty())
+  {
+    OpenItemInArchive(index, false, true, true, useEditor);
+    return;
+  }
+  CProcess process;
+  StartEditApplication(GetItemFullPath(index), useEditor, (HWND)*this, process);
+}
+
+
+void CPanel::OpenFolderExternal(int index)
+{
+  UString prefix = GetFsPath();
+  UString path = prefix;
+
+  if (index == kParentIndex)
+  {
+    if (prefix.IsEmpty())
+      return;
+    const wchar_t c = prefix.Back();
+    if (!IS_PATH_SEPAR(c) && c != ':')
+      return;
+    prefix.DeleteBack();
+    int pos = prefix.ReverseFind_PathSepar();
+    if (pos < 0)
+      return;
+    prefix.DeleteFrom((unsigned)(pos + 1));
+    path = prefix;
+  }
+  else
+  {
+    path += GetItemRelPath(index);
+    path.Add_PathSepar();
+  }
+
+  StartApplicationDontWait(prefix, path, (HWND)*this);
+}
+
+
+bool CPanel::IsVirus_Message(const UString &name)
+{
+  UString name2;
+
+  const wchar_t cRLO = (wchar_t)0x202E;
+  bool isVirus = false;
+  bool isSpaceError = false;
+  name2 = name;
+  
+  if (name2.Find(cRLO) >= 0)
+  {
+    const UString badString(cRLO);
+    name2.Replace(badString, L"[RLO]");
+    isVirus = true;
+  }
+  {
+    const wchar_t * const kVirusSpaces = L"     ";
+    // const unsigned kNumSpaces = strlen(kVirusSpaces);
+    for (;;)
+    {
+      int pos = name2.Find(kVirusSpaces);
+      if (pos < 0)
+        break;
+      isVirus = true;
+      isSpaceError = true;
+      name2.Replace(kVirusSpaces, L" ");
+    }
+  }
+
+  #ifdef _WIN32
+  {
+    unsigned i;
+    for (i = name2.Len(); i != 0;)
+    {
+      wchar_t c = name2[i - 1];
+      if (c != '.' && c != ' ')
+        break;
+      i--;
+      name2.ReplaceOneCharAtPos(i, '_');
+    }
+    if (i != name2.Len())
+    {
+      UString name3 = name2;
+      name3.DeleteFrom(i);
+      if (FindExt(kExeExtensions, name3))
+        isVirus = true;
+    }
+  }
+  #endif
+  
+  if (!isVirus)
+    return false;
+
+  UString s = LangString(IDS_VIRUS);
+  
+  if (!isSpaceError)
+  {
+    int pos1 = s.Find(L'(');
+    if (pos1 >= 0)
+    {
+      int pos2 = s.Find(L')', pos1 + 1);
+      if (pos2 >= 0)
+      {
+        s.Delete(pos1, pos2 + 1 - pos1);
+        if (pos1 > 0 && s[pos1 - 1] == ' ' && s[pos1] == '.')
+          s.Delete(pos1 - 1);
+      }
+    }
+  }
+
+  UString name3 = name;
+  name3.Replace(L'\n', L'_');
+  name2.Replace(L'\n', L'_');
+
+  s.Add_LF(); s += name2;
+  s.Add_LF(); s += name3;
+
+  MessageBox_Error(s);
+  return true;
+}
+
+
+void CPanel::OpenItem(int index, bool tryInternal, bool tryExternal, const wchar_t *type)
+{
+  CDisableTimerProcessing disableTimerProcessing(*this);
+  UString name = GetItemRelPath2(index);
+  
+  if (tryExternal)
+    if (IsVirus_Message(name))
+      return;
+
+  if (!_parentFolders.IsEmpty())
+  {
+    OpenItemInArchive(index, tryInternal, tryExternal, false, false, type);
+    return;
+  }
+
+  CDisableNotify disableNotify(*this);
+  UString prefix = GetFsPath();
+  UString fullPath = prefix + name;
+
+  if (tryInternal)
+    if (!tryExternal || !DoItemAlwaysStart(name))
+    {
+      HRESULT res = OpenAsArc_Index(index, type
+          // , true
+          );
+      disableNotify.Restore(); // we must restore to allow text notification update
+      InvalidateList();
+      if (res == S_OK || res == E_ABORT)
+        return;
+      if (res != S_FALSE)
+      {
+        MessageBox_Error_HRESULT(res);
+        return;
+      }
+    }
+  
+  if (tryExternal)
+  {
+    // SetCurrentDirectory opens HANDLE to folder!!!
+    // NDirectory::MySetCurrentDirectory(prefix);
+    StartApplicationDontWait(prefix, fullPath, (HWND)*this);
+  }
+}
+
+class CThreadCopyFrom: public CProgressThreadVirt
+{
+  HRESULT ProcessVirt();
+public:
+  UString FullPath;
+  UInt32 ItemIndex;
+
+  CMyComPtr<IFolderOperations> FolderOperations;
+  CMyComPtr<IProgress> UpdateCallback;
+  CUpdateCallback100Imp *UpdateCallbackSpec;
+};
+  
+HRESULT CThreadCopyFrom::ProcessVirt()
+{
+  return FolderOperations->CopyFromFile(ItemIndex, FullPath, UpdateCallback);
+}
+      
+HRESULT CPanel::OnOpenItemChanged(UInt32 index, const wchar_t *fullFilePath,
+    bool usePassword, const UString &password)
+{
+  if (!_folderOperations)
+  {
+    MessageBox_Error_UnsupportOperation();
+    return E_FAIL;
+  }
+
+  CThreadCopyFrom t;
+  t.UpdateCallbackSpec = new CUpdateCallback100Imp;
+  t.UpdateCallback = t.UpdateCallbackSpec;
+  t.UpdateCallbackSpec->ProgressDialog = &t;
+  t.ItemIndex = index;
+  t.FullPath = fullFilePath;
+  t.FolderOperations = _folderOperations;
+
+  t.UpdateCallbackSpec->Init();
+  t.UpdateCallbackSpec->PasswordIsDefined = usePassword;
+  t.UpdateCallbackSpec->Password = password;
+
+
+  RINOK(t.Create(GetItemName(index), (HWND)*this));
+  return t.Result;
+}
+
+LRESULT CPanel::OnOpenItemChanged(LPARAM lParam)
+{
+  // DEBUG_PRINT_NUM("OnOpenItemChanged", GetCurrentThreadId());
+
+  CTmpProcessInfo &tpi = *(CTmpProcessInfo *)lParam;
+  if (tpi.FullPathFolderPrefix != _currentFolderPrefix)
+    return 0;
+  UInt32 fileIndex = tpi.FileIndex;
+  UInt32 numItems;
+  _folder->GetNumberOfItems(&numItems);
+  
+  // This code is not 100% OK for cases when there are several files with
+  // tpi.RelPath name and there are changes in archive before update.
+  // So tpi.FileIndex can point to another file.
+ 
+  if (fileIndex >= numItems || GetItemRelPath(fileIndex) != tpi.RelPath)
+  {
+    UInt32 i;
+    for (i = 0; i < numItems; i++)
+      if (GetItemRelPath(i) == tpi.RelPath)
+        break;
+    if (i == numItems)
+      return 0;
+    fileIndex = i;
+  }
+
+  CSelectedState state;
+  SaveSelectedState(state);
+
+  CDisableNotify disableNotify(*this); // do we need it??
+
+  HRESULT result = OnOpenItemChanged(fileIndex, fs2us(tpi.FilePath), tpi.UsePassword, tpi.Password);
+  RefreshListCtrl(state);
+  if (result != S_OK)
+    return 0;
+  return 1;
+}
+
+
+CExitEventLauncher g_ExitEventLauncher;
+
+void CExitEventLauncher::Exit(bool hardExit)
+{
+  if (_needExit)
+  {
+    _exitEvent.Set();
+    _needExit = false;
+  }
+
+  if (_numActiveThreads == 0)
+    return;
+  
+  FOR_VECTOR (i, _threads)
+  {
+    ::CThread &th = _threads[i];
+    DWORD wait = (hardExit ? 100 : INFINITE);
+    if (Thread_WasCreated(&th))
+    {
+      DWORD waitResult = WaitForSingleObject(th, wait);
+      // Thread_Wait(&th);
+      if (waitResult == WAIT_TIMEOUT)
+        wait = 1;
+      if (!hardExit && waitResult != WAIT_OBJECT_0)
+        continue;
+      Thread_Close(&th);
+      _numActiveThreads--;
+    }
+  }
+}
+
+
+
+static THREAD_FUNC_DECL MyThreadFunction(void *param)
+{
+  DEBUG_PRINT("==== MyThreadFunction ====");
+
+  CMyAutoPtr<CTmpProcessInfo> tmpProcessInfoPtr((CTmpProcessInfo *)param);
+  CTmpProcessInfo *tpi = tmpProcessInfoPtr.get();
+  CChildProcesses &processes = tpi->Processes;
+
+  bool mainProcessWasSet = !processes.Handles.IsEmpty();
+
+  bool isComplexMode = true;
+
+  if (!processes.Handles.IsEmpty())
+  {
+
+  const DWORD startTime = GetTickCount();
+
+  /*
+  CPossibleProgs progs;
+  {
+    const UString &name = tpi->RelPath;
+    int slashPos = name.ReverseFind_PathSepar();
+    int dotPos = name.ReverseFind_Dot();
+    if (dotPos > slashPos)
+    {
+      const UString ext = name.Ptr(dotPos + 1);
+      AString extA = UnicodeStringToMultiByte(ext);
+      extA.MakeLower_Ascii();
+      progs.SetFromExtension(extA);
+    }
+  }
+  */
+
+  bool firstPass = true;
+
+  for (;;)
+  {
+    CRecordVector<HANDLE> handles;
+    CUIntVector indices;
+    
+    FOR_VECTOR (i, processes.Handles)
+    {
+      if (handles.Size() > 60)
+        break;
+      if (processes.NeedWait[i])
+      {
+        handles.Add(processes.Handles[i]);
+        indices.Add(i);
+      }
+    }
+    
+    bool needFindProcessByPath = false;
+
+    if (handles.IsEmpty())
+    {
+      if (!firstPass)
+        break;
+    }
+    else
+    {
+      handles.Add(g_ExitEventLauncher._exitEvent);
+      
+      DWORD waitResult = WaitForMultiObj_Any_Infinite(handles.Size(), &handles.Front());
+      
+      waitResult -= WAIT_OBJECT_0;
+      
+      if (waitResult >= handles.Size() - 1)
+      {
+        processes.CloseAll();
+        /*
+        if (waitResult == handles.Size() - 1)
+        {
+          // exit event
+          // we want to delete temp files, if progs were used
+          if (processes.ProgsWereUsed)
+            break;
+        }
+        */
+        return waitResult >= (DWORD)handles.Size() ? 1 : 0;
+      }
+
+      if (firstPass && indices.Size() == 1)
+      {
+        DWORD curTime = GetTickCount() - startTime;
+
+        /*
+        if (curTime > 5 * 1000)
+          progs.ProgNames.Clear();
+        */
+
+        needFindProcessByPath = (curTime < 2 * 1000);
+
+        if (needFindProcessByPath)
+        {
+          NFind::CFileInfo newFileInfo;
+          if (newFileInfo.Find(tpi->FilePath))
+            if (tpi->WasChanged(newFileInfo))
+              needFindProcessByPath = false;
+        }
+        
+        DEBUG_PRINT_NUM(" -- firstPass -- time = ", curTime)
+      }
+      
+      processes.DisableWait(indices[waitResult]);
+    }
+
+    firstPass = false;
+    
+    // Sleep(300);
+    #ifndef UNDER_CE
+    processes.Update(needFindProcessByPath /* , progs */);
+    #endif
+  }
+
+
+  DWORD curTime = GetTickCount() - startTime;
+
+  DEBUG_PRINT_NUM("after time = ", curTime)
+
+  processes.CloseAll();
+
+  isComplexMode = (curTime < 2 * 1000);
+
+  }
+
+  bool needCheckTimestamp = true;
+
+  for (;;)
+  {
+    NFind::CFileInfo newFileInfo;
+    
+    if (!newFileInfo.Find(tpi->FilePath))
+      break;
+
+    if (mainProcessWasSet)
+    {
+      if (tpi->WasChanged(newFileInfo))
+      {
+        UString m = MyFormatNew(IDS_CANNOT_UPDATE_FILE, fs2us(tpi->FilePath));
+        if (tpi->ReadOnly)
+        {
+          m.Add_LF();
+          AddLangString(m, IDS_PROP_READ_ONLY);
+          m.Add_LF();
+          m += tpi->FullPathFolderPrefix;
+          ::MessageBoxW(g_HWND, m, L"7-Zip", MB_OK | MB_ICONSTOP);
+          return 0;
+        }
+        {
+          const UString message = MyFormatNew(IDS_WANT_UPDATE_MODIFIED_FILE, tpi->RelPath);
+          if (::MessageBoxW(g_HWND, message, L"7-Zip", MB_OKCANCEL | MB_ICONQUESTION) == IDOK)
+          {
+            // DEBUG_PRINT_NUM("SendMessage", GetCurrentThreadId());
+            if (SendMessage(tpi->Window, kOpenItemChanged, 0, (LONG_PTR)tpi) != 1)
+            {
+              ::MessageBoxW(g_HWND, m, L"7-Zip", MB_OK | MB_ICONSTOP);
+              return 0;
+            }
+          }
+          needCheckTimestamp = false;
+          break;
+        }
+      }
+    
+      if (!isComplexMode)
+        break;
+    }
+    
+    // DEBUG_PRINT("WaitForSingleObject");
+    DWORD waitResult = ::WaitForSingleObject(g_ExitEventLauncher._exitEvent, INFINITE);
+    // DEBUG_PRINT("---");
+
+    if (waitResult == WAIT_OBJECT_0)
+      break;
+
+    return 1;
+  }
+
+  {
+    NFind::CFileInfo newFileInfo;
+    
+    bool finded = newFileInfo.Find(tpi->FilePath);
+
+    if (!needCheckTimestamp || !finded || !tpi->WasChanged(newFileInfo))
+    {
+      DEBUG_PRINT("Delete Temp file");
+      tpi->DeleteDirAndFile();
+    }
+  }
+  
+  return 0;
+}
+
+
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+static const FChar * const k_ZoneId_StreamName = FTEXT(":Zone.Identifier");
+#endif
+
+
+#ifndef UNDER_CE
+
+static void ReadZoneFile(CFSTR fileName, CByteBuffer &buf)
+{
+  buf.Free();
+  NIO::CInFile file;
+  if (!file.Open(fileName))
+    return;
+  UInt64 fileSize;
+  if (!file.GetLength(fileSize))
+    return;
+  if (fileSize == 0 || fileSize >= ((UInt32)1 << 20))
+    return;
+  buf.Alloc((size_t)fileSize);
+  size_t processed;
+  if (file.ReadFull(buf, (size_t)fileSize, processed) && processed == fileSize)
+    return;
+  buf.Free();
+}
+
+static bool WriteZoneFile(CFSTR fileName, const CByteBuffer &buf)
+{
+  NIO::COutFile file;
+  if (!file.Create(fileName, true))
+    return false;
+  UInt32 processed;
+  if (!file.Write(buf, (UInt32)buf.Size(), processed))
+    return false;
+  return processed == buf.Size();
+}
+
+#endif
+
+/*
+class CBufSeqOutStream_WithFile:
+  public ISequentialOutStream,
+  public CMyUnknownImp
+{
+  Byte *_buffer;
+  size_t _size;
+  size_t _pos;
+
+
+  size_t _fileWritePos;
+  bool fileMode;
+public:
+
+  bool IsStreamInMem() const { return !fileMode; }
+  size_t GetMemStreamWrittenSize() const { return _pos; }
+
+  // ISequentialOutStream *FileStream;
+  FString FilePath;
+  COutFileStream *outFileStreamSpec;
+  CMyComPtr<ISequentialOutStream> outFileStream;
+
+  CBufSeqOutStream_WithFile(): outFileStreamSpec(NULL) {}
+
+  void Init(Byte *buffer, size_t size)
+  {
+    fileMode = false;
+    _buffer = buffer;
+    _pos = 0;
+    _size = size;
+    _fileWritePos = 0;
+  }
+
+  HRESULT FlushToFile();
+  size_t GetPos() const { return _pos; }
+
+  MY_UNKNOWN_IMP
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+};
+
+static const UInt32 kBlockSize = ((UInt32)1 << 31);
+
+STDMETHODIMP CBufSeqOutStream_WithFile::Write(const void *data, UInt32 size, UInt32 *processedSize)
+{
+  if (processedSize)
+    *processedSize = 0;
+  if (!fileMode)
+  {
+    if (_size - _pos >= size)
+    {
+      if (size != 0)
+      {
+        memcpy(_buffer + _pos, data, size);
+        _pos += size;
+      }
+      if (processedSize)
+        *processedSize = (UInt32)size;
+      return S_OK;
+    }
+
+    fileMode = true;
+  }
+  RINOK(FlushToFile());
+  return outFileStream->Write(data, size, processedSize);
+}
+
+HRESULT CBufSeqOutStream_WithFile::FlushToFile()
+{
+  if (!outFileStream)
+  {
+    outFileStreamSpec = new COutFileStream;
+    outFileStream = outFileStreamSpec;
+    if (!outFileStreamSpec->Create(FilePath, false))
+    {
+      outFileStream.Release();
+      return E_FAIL;
+      // MessageBoxMyError(UString("Can't create file ") + fs2us(tempFilePath));
+    }
+  }
+  while (_fileWritePos != _pos)
+  {
+    size_t cur = _pos - _fileWritePos;
+    UInt32 curSize = (cur < kBlockSize) ? (UInt32)cur : kBlockSize;
+    UInt32 processedSizeLoc = 0;
+    HRESULT res = outFileStream->Write(_buffer + _fileWritePos, curSize, &processedSizeLoc);
+    _fileWritePos += processedSizeLoc;
+    RINOK(res);
+    if (processedSizeLoc == 0)
+      return E_FAIL;
+  }
+  return S_OK;
+}
+*/
+
+/*
+static HRESULT GetTime(IFolderFolder *folder, UInt32 index, PROPID propID, FILETIME &filetime, bool &filetimeIsDefined)
+{
+  filetimeIsDefined = false;
+  NCOM::CPropVariant prop;
+  RINOK(folder->GetProperty(index, propID, &prop));
+  if (prop.vt == VT_FILETIME)
+  {
+    filetime = prop.filetime;
+    filetimeIsDefined = (filetime.dwHighDateTime != 0 || filetime.dwLowDateTime != 0);
+  }
+  else if (prop.vt != VT_EMPTY)
+    return E_FAIL;
+  return S_OK;
+}
+*/
+
+
+/*
+tryInternal tryExternal
+  false       false      : unused
+  false       true       : external
+  true        false      : internal
+  true        true       : smart based on file extension:
+                      !alwaysStart(name) : both
+                      alwaysStart(name)  : external
+*/
+
+void CPanel::OpenItemInArchive(int index, bool tryInternal, bool tryExternal, bool editMode, bool useEditor, const wchar_t *type)
+{
+  // we don't want to change hash data here
+  if (IsHashFolder())
+    return;
+
+  const UString name = GetItemName(index);
+  const UString relPath = GetItemRelPath(index);
+  
+  if (tryExternal)
+    if (IsVirus_Message(name))
+      return;
+
+  if (!_folderOperations)
+  {
+    MessageBox_Error_UnsupportOperation();
+    return;
+  }
+
+  bool tryAsArchive = tryInternal && (!tryExternal || !DoItemAlwaysStart(name));
+
+  const UString fullVirtPath = _currentFolderPrefix + relPath;
+
+  CTempDir tempDirectory;
+  if (!tempDirectory.Create(kTempDirPrefix))
+  {
+    MessageBox_LastError();
+    return;
+  }
+  
+  FString tempDir = tempDirectory.GetPath();
+  FString tempDirNorm = tempDir;
+  NName::NormalizeDirPathPrefix(tempDirNorm);
+  const FString tempFilePath = tempDirNorm + us2fs(Get_Correct_FsFile_Name(name));
+
+  CTempFileInfo tempFileInfo;
+  tempFileInfo.FileIndex = index;
+  tempFileInfo.RelPath = relPath;
+  tempFileInfo.FolderPath = tempDir;
+  tempFileInfo.FilePath = tempFilePath;
+  tempFileInfo.NeedDelete = true;
+
+  if (tryAsArchive)
+  {
+    CMyComPtr<IInArchiveGetStream> getStream;
+    _folder.QueryInterface(IID_IInArchiveGetStream, &getStream);
+    if (getStream)
+    {
+      CMyComPtr<ISequentialInStream> subSeqStream;
+      getStream->GetStream(index, &subSeqStream);
+      if (subSeqStream)
+      {
+        CMyComPtr<IInStream> subStream;
+        subSeqStream.QueryInterface(IID_IInStream, &subStream);
+        if (subStream)
+        {
+          HRESULT res = OpenAsArc_Msg(subStream, tempFileInfo, fullVirtPath, type ? type : L""
+              // , true // showErrorMessage
+              );
+          if (res == S_OK)
+          {
+            tempDirectory.DisableDeleting();
+            RefreshListCtrl();
+            return;
+          }
+          if (res == E_ABORT || res != S_FALSE)
+            return;
+          if (!tryExternal)
+            return;
+          tryAsArchive = false;
+        }
+      }
+    }
+  }
+
+
+  CRecordVector<UInt32> indices;
+  indices.Add(index);
+
+  UStringVector messages;
+
+  bool usePassword = false;
+  UString password;
+  if (_parentFolders.Size() > 0)
+  {
+    const CFolderLink &fl = _parentFolders.Back();
+    usePassword = fl.UsePassword;
+    password = fl.Password;
+  }
+
+  #if defined(_WIN32) && !defined(UNDER_CE)
+  CByteBuffer zoneBuf;
+  #ifndef _UNICODE
+  if (g_IsNT)
+  #endif
+  if (_parentFolders.Size() > 0)
+  {
+    const CFolderLink &fl = _parentFolders.Front();
+    if (!fl.IsVirtual && !fl.FilePath.IsEmpty())
+      ReadZoneFile(fl.FilePath + k_ZoneId_StreamName, zoneBuf);
+  }
+  #endif
+
+
+  CVirtFileSystem *virtFileSystemSpec = NULL;
+  CMyComPtr<ISequentialOutStream> virtFileSystem;
+
+  bool isAltStream = IsItem_AltStream(index);
+
+  CCopyToOptions options;
+  options.includeAltStreams = true;
+  options.replaceAltStreamChars = isAltStream;
+  
+  if (tryAsArchive)
+  {
+    NCOM::CPropVariant prop;
+    _folder->GetProperty(index, kpidSize, &prop);
+    UInt64 fileLimit = 1 << 22;
+    if (g_RAM_Size_Defined)
+      fileLimit = g_RAM_Size / 4;
+
+    UInt64 fileSize = 0;
+    if (!ConvertPropVariantToUInt64(prop, fileSize))
+      fileSize = fileLimit;
+    if (fileSize <= fileLimit && fileSize > 0)
+    {
+      options.streamMode = true;
+      virtFileSystemSpec = new CVirtFileSystem;
+      virtFileSystem = virtFileSystemSpec;
+      // we allow additional total size for small alt streams;
+      virtFileSystemSpec->MaxTotalAllocSize = fileSize + (1 << 10);
+      
+      virtFileSystemSpec->DirPrefix = tempDirNorm;
+      virtFileSystemSpec->Init();
+      options.VirtFileSystem = virtFileSystem;
+      options.VirtFileSystemSpec = virtFileSystemSpec;
+    }
+  }
+
+  options.folder = fs2us(tempDirNorm);
+  options.showErrorMessages = true;
+
+  HRESULT result = CopyTo(options, indices, &messages, usePassword, password);
+
+  if (_parentFolders.Size() > 0)
+  {
+    CFolderLink &fl = _parentFolders.Back();
+    fl.UsePassword = usePassword;
+    fl.Password = password;
+  }
+
+  if (!messages.IsEmpty())
+    return;
+  if (result != S_OK)
+  {
+    if (result != E_ABORT)
+      MessageBox_Error_HRESULT(result);
+    return;
+  }
+
+  if (options.VirtFileSystem)
+  {
+    if (virtFileSystemSpec->IsStreamInMem())
+    {
+      const CVirtFile &file = virtFileSystemSpec->Files[0];
+
+      size_t streamSize = (size_t)file.Size;
+      CBufInStream *bufInStreamSpec = new CBufInStream;
+      CMyComPtr<IInStream> bufInStream = bufInStreamSpec;
+      bufInStreamSpec->Init(file.Data, streamSize, virtFileSystem);
+
+      HRESULT res = OpenAsArc_Msg(bufInStream, tempFileInfo, fullVirtPath, type ? type : L""
+          // , encrypted
+          // , true // showErrorMessage
+          );
+
+      if (res == S_OK)
+      {
+        tempDirectory.DisableDeleting();
+        RefreshListCtrl();
+        return;
+      }
+
+      if (res == E_ABORT || res != S_FALSE)
+        return;
+      if (!tryExternal)
+        return;
+      
+      tryAsArchive = false;
+      if (virtFileSystemSpec->FlushToDisk(true) != S_OK)
+        return;
+    }
+  }
+
+
+  #if defined(_WIN32) && !defined(UNDER_CE)
+  if (zoneBuf.Size() != 0)
+  {
+    if (NFind::DoesFileExist_Raw(tempFilePath))
+    {
+      WriteZoneFile(tempFilePath + k_ZoneId_StreamName, zoneBuf);
+    }
+  }
+  #endif
+
+
+  if (tryAsArchive)
+  {
+    HRESULT res = OpenAsArc_Msg(NULL, tempFileInfo, fullVirtPath, type ? type : L""
+        // , encrypted
+        // , true // showErrorMessage
+        );
+    if (res == S_OK)
+    {
+      tempDirectory.DisableDeleting();
+      RefreshListCtrl();
+      return;
+    }
+    if (res == E_ABORT || res != S_FALSE)
+      return;
+  }
+
+  if (!tryExternal)
+    return;
+
+  CMyAutoPtr<CTmpProcessInfo> tmpProcessInfoPtr(new CTmpProcessInfo());
+  CTmpProcessInfo *tpi = tmpProcessInfoPtr.get();
+  tpi->FolderPath = tempDir;
+  tpi->FilePath = tempFilePath;
+  tpi->NeedDelete = true;
+  tpi->UsePassword = usePassword;
+  tpi->Password = password;
+  tpi->ReadOnly = IsThereReadOnlyFolder();
+  if (IsHashFolder())
+    tpi->ReadOnly = true;
+
+  if (!tpi->FileInfo.Find(tempFilePath))
+    return;
+
+  CTmpProcessInfoRelease tmpProcessInfoRelease(*tpi);
+
+  CProcess process;
+  HRESULT res;
+  if (editMode)
+    res = StartEditApplication(fs2us(tempFilePath), useEditor, (HWND)*this, process);
+  else
+    res = StartApplication(fs2us(tempDirNorm), fs2us(tempFilePath), (HWND)*this, process);
+
+  if ((HANDLE)process == NULL)
+  {
+    // win7 / win10 work so for some extensions (pdf, html ..);
+    DEBUG_PRINT("#### (HANDLE)process == 0");
+    // return;
+    if (res != SZ_OK)
+      return;
+  }
+
+  tpi->Window = (HWND)(*this);
+  tpi->FullPathFolderPrefix = _currentFolderPrefix;
+  tpi->FileIndex = index;
+  tpi->RelPath = relPath;
+  
+  if ((HANDLE)process != 0)
+    tpi->Processes.SetMainProcess(process.Detach());
+
+  ::CThread th;
+  if (Thread_Create(&th, MyThreadFunction, tpi) != 0)
+    throw 271824;
+  g_ExitEventLauncher._threads.Add(th);
+  g_ExitEventLauncher._numActiveThreads++;
+
+  tempDirectory.DisableDeleting();
+  tmpProcessInfoPtr.release();
+  tmpProcessInfoRelease._needDelete = false;
+}
+
+
+/*
+static const UINT64 kTimeLimit = UINT64(10000000) * 3600 * 24;
+
+static bool CheckDeleteItem(UINT64 currentFileTime, UINT64 folderFileTime)
+{
+  return (currentFileTime - folderFileTime > kTimeLimit &&
+      folderFileTime - currentFileTime > kTimeLimit);
+}
+
+void DeleteOldTempFiles()
+{
+  UString tempPath;
+  if (!MyGetTempPath(tempPath))
+    throw 1;
+
+  UINT64 currentFileTime;
+  NTime::GetCurUtcFileTime(currentFileTime);
+  UString searchWildCard = tempPath + kTempDirPrefix + L"*.tmp";
+  searchWildCard += WCHAR(NName::kAnyStringWildcard);
+  NFind::CEnumeratorW enumerator(searchWildCard);
+  NFind::CFileInfo fileInfo;
+  while (enumerator.Next(fileInfo))
+  {
+    if (!fileInfo.IsDir())
+      continue;
+    const UINT64 &cTime = *(const UINT64 *)(&fileInfo.CTime);
+    if (CheckDeleteItem(cTime, currentFileTime))
+      RemoveDirectoryWithSubItems(tempPath + fileInfo.Name);
+  }
+}
+*/
diff --git a/CPP/7zip/UI/FileManager/PanelItems.cpp b/CPP/7zip/UI/FileManager/PanelItems.cpp
new file mode 100644
index 0000000..33e4458
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelItems.cpp
@@ -0,0 +1,1306 @@
+// PanelItems.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/Sort.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/Menu.h"
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#include "../../PropID.h"
+
+#include "../Common/ExtractingFilePath.h"
+
+#include "resource.h"
+
+#include "LangUtils.h"
+#include "Panel.h"
+#include "PropertyName.h"
+#include "RootFolder.h"
+
+using namespace NWindows;
+
+static bool GetColumnVisible(PROPID propID, bool isFsFolder)
+{
+  if (isFsFolder)
+  {
+    switch (propID)
+    {
+      case kpidATime:
+      case kpidAttrib:
+      case kpidPackSize:
+      case kpidINode:
+      case kpidLinks:
+      case kpidNtReparse:
+        return false;
+    }
+  }
+  return true;
+}
+
+static int GetColumnWidth(PROPID propID, VARTYPE /* varType */)
+{
+  switch (propID)
+  {
+    case kpidName: return 160;
+  }
+  return 100;
+}
+
+static int GetColumnAlign(PROPID propID, VARTYPE varType)
+{
+  switch (propID)
+  {
+    case kpidCTime:
+    case kpidATime:
+    case kpidMTime:
+      return LVCFMT_LEFT;
+  }
+  
+  switch (varType)
+  {
+    case VT_UI1:
+    case VT_I2:
+    case VT_UI2:
+    case VT_I4:
+    case VT_INT:
+    case VT_UI4:
+    case VT_UINT:
+    case VT_I8:
+    case VT_UI8:
+    case VT_BOOL:
+      return LVCFMT_RIGHT;
+    
+    case VT_EMPTY:
+    case VT_I1:
+    case VT_FILETIME:
+    case VT_BSTR:
+      return LVCFMT_LEFT;
+    
+    default:
+      return LVCFMT_CENTER;
+  }
+}
+
+
+static int ItemProperty_Compare_NameFirst(void *const *a1, void *const *a2, void * /* param */)
+{
+  return (*(*((const CPropColumn *const *)a1))).Compare_NameFirst(*(*((const CPropColumn *const *)a2)));
+}
+
+HRESULT CPanel::InitColumns()
+{
+  SaveListViewInfo();
+
+  // DeleteListItems();
+  _selectedStatusVector.Clear();
+
+  {
+    // ReadListViewInfo();
+    const UString oldType = _typeIDString;
+    _typeIDString = GetFolderTypeID();
+    // an empty _typeIDString is allowed.
+    
+    // we read registry only for new FolderTypeID
+    if (!_needSaveInfo || _typeIDString != oldType)
+      _listViewInfo.Read(_typeIDString);
+    
+    // folders with same FolderTypeID can have different columns
+    // so we still read columns for that case.
+    // if (_needSaveInfo && _typeIDString == oldType) return S_OK;
+  }
+
+  // PROPID sortID;
+  /*
+  if (_listViewInfo.SortIndex >= 0)
+    sortID = _listViewInfo.Columns[_listViewInfo.SortIndex].PropID;
+  */
+  // sortID = _listViewInfo.SortID;
+
+  _ascending = _listViewInfo.Ascending;
+
+  _columns.Clear();
+
+  bool isFsFolder = IsFSFolder() || IsAltStreamsFolder();
+
+  {
+    UInt32 numProps;
+    _folder->GetNumberOfProperties(&numProps);
+    
+    for (UInt32 i = 0; i < numProps; i++)
+    {
+      CMyComBSTR name;
+      PROPID propID;
+      VARTYPE varType;
+      HRESULT res = _folder->GetPropertyInfo(i, &name, &propID, &varType);
+      
+      if (res != S_OK)
+      {
+        /* We can return ERROR, but in that case, other code will not be called,
+           and user can see empty window without error message. So we just ignore that field */
+        continue;
+      }
+      if (propID == kpidIsDir)
+        continue;
+      CPropColumn prop;
+      prop.Type = varType;
+      prop.ID = propID;
+      prop.Name = GetNameOfProperty(propID, name);
+      prop.Order = -1;
+      prop.IsVisible = GetColumnVisible(propID, isFsFolder);
+      prop.Width = GetColumnWidth(propID, varType);
+      prop.IsRawProp = false;
+      _columns.Add(prop);
+    }
+
+    /*
+    {
+      // debug column
+      CPropColumn prop;
+      prop.Type = VT_BSTR;
+      prop.ID = 2000;
+      prop.Name = "Debug";
+      prop.Order = -1;
+      prop.IsVisible = true;
+      prop.Width = 300;
+      prop.IsRawProp = false;
+      _columns.Add(prop);
+    }
+    */
+  }
+
+  if (_folderRawProps)
+  {
+    UInt32 numProps;
+    _folderRawProps->GetNumRawProps(&numProps);
+    
+    for (UInt32 i = 0; i < numProps; i++)
+    {
+      CMyComBSTR name;
+      PROPID propID;
+      HRESULT res = _folderRawProps->GetRawPropInfo(i, &name, &propID);
+      if (res != S_OK)
+        continue;
+      CPropColumn prop;
+      prop.Type = VT_EMPTY;
+      prop.ID = propID;
+      prop.Name = GetNameOfProperty(propID, name);
+      prop.Order = -1;
+      prop.IsVisible = GetColumnVisible(propID, isFsFolder);
+      prop.Width = GetColumnWidth(propID, VT_BSTR);
+      prop.IsRawProp = true;
+      _columns.Add(prop);
+    }
+  }
+
+  unsigned order = 0;
+  unsigned i;
+  
+  for (i = 0; i < _listViewInfo.Columns.Size(); i++)
+  {
+    const CColumnInfo &columnInfo = _listViewInfo.Columns[i];
+    int index = _columns.FindItem_for_PropID(columnInfo.PropID);
+    if (index >= 0)
+    {
+      CPropColumn &item = _columns[index];
+      if (item.Order >= 0)
+        continue; // we ignore duplicated items
+      bool isVisible = columnInfo.IsVisible;
+      // we enable kpidName, if it was disabled by some incorrect code
+      if (columnInfo.PropID == kpidName)
+        isVisible = true;
+      item.IsVisible = isVisible;
+      item.Width = columnInfo.Width;
+      if (isVisible)
+        item.Order = order++;
+      continue;
+    }
+  }
+
+  for (i = 0; i < _columns.Size(); i++)
+  {
+    CPropColumn &item = _columns[i];
+    if (item.IsVisible && item.Order < 0)
+      item.Order = order++;
+  }
+  
+  for (i = 0; i < _columns.Size(); i++)
+  {
+    CPropColumn &item = _columns[i];
+    if (item.Order < 0)
+      item.Order = order++;
+  }
+
+  CPropColumns newColumns;
+  
+  for (i = 0; i < _columns.Size(); i++)
+  {
+    const CPropColumn &prop = _columns[i];
+    if (prop.IsVisible)
+      newColumns.Add(prop);
+  }
+
+
+  /*
+  _sortIndex = 0;
+  if (_listViewInfo.SortIndex >= 0)
+  {
+    int sortIndex = _columns.FindItem_for_PropID(sortID);
+    if (sortIndex >= 0)
+      _sortIndex = sortIndex;
+  }
+  */
+
+  if (_listViewInfo.IsLoaded)
+    _sortID = _listViewInfo.SortID;
+  else
+  {
+    _sortID = 0;
+    if (IsFSFolder() || IsAltStreamsFolder() || IsArcFolder())
+      _sortID = kpidName;
+  }
+
+  /* There are restrictions in ListView control:
+     1) main column (kpidName) must have (LV_COLUMNW::iSubItem = 0)
+        So we need special sorting for columns.
+     2) when we add new column, LV_COLUMNW::iOrder cannot be larger than already inserted columns)
+        So we set column order after all columns are added.
+  */
+  newColumns.Sort(ItemProperty_Compare_NameFirst, NULL);
+  
+  if (newColumns.IsEqualTo(_visibleColumns))
+    return S_OK;
+
+  CIntArr columns(newColumns.Size());
+  for (i = 0; i < newColumns.Size(); i++)
+    columns[i] = -1;
+  
+  bool orderError = false;
+  
+  for (i = 0; i < newColumns.Size(); i++)
+  {
+    const CPropColumn &prop = newColumns[i];
+    if (prop.Order < (int)newColumns.Size() && columns[prop.Order] == -1)
+      columns[prop.Order] = i;
+    else
+      orderError = true;
+  }
+
+  for (;;)
+  {
+    unsigned numColumns = _visibleColumns.Size();
+    if (numColumns == 0)
+      break;
+    DeleteColumn(numColumns - 1);
+  }
+
+  for (i = 0; i < newColumns.Size(); i++)
+    AddColumn(newColumns[i]);
+
+  // columns[0], columns[1], .... should be displayed from left to right:
+  if (!orderError)
+    _listView.SetColumnOrderArray(_visibleColumns.Size(), columns);
+
+  _needSaveInfo = true;
+
+  return S_OK;
+}
+
+
+void CPanel::DeleteColumn(unsigned index)
+{
+  _visibleColumns.Delete(index);
+  _listView.DeleteColumn(index);
+}
+
+void CPanel::AddColumn(const CPropColumn &prop)
+{
+  const int index = _visibleColumns.Size();
+  
+  LV_COLUMNW column;
+  column.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM | LVCF_ORDER;
+  column.cx = prop.Width;
+  column.fmt = GetColumnAlign(prop.ID, prop.Type);
+  column.iOrder = index; // must be <= _listView.ItemCount
+  column.iSubItem = index; // must be <= _listView.ItemCount
+  column.pszText = const_cast<wchar_t *>((const wchar_t *)prop.Name);
+
+  _visibleColumns.Add(prop);
+  _listView.InsertColumn(index, &column);
+}
+
+
+HRESULT CPanel::RefreshListCtrl()
+{
+  CSelectedState state;
+  return RefreshListCtrl(state);
+}
+
+int CALLBACK CompareItems(LPARAM lParam1, LPARAM lParam2, LPARAM lpData);
+
+
+void CPanel::GetSelectedNames(UStringVector &selectedNames)
+{
+  CRecordVector<UInt32> indices;
+  GetSelectedItemsIndices(indices);
+  selectedNames.ClearAndReserve(indices.Size());
+  FOR_VECTOR (i, indices)
+    selectedNames.AddInReserved(GetItemRelPath(indices[i]));
+
+  /*
+  for (int i = 0; i < _listView.GetItemCount(); i++)
+  {
+    const int kSize = 1024;
+    WCHAR name[kSize + 1];
+    LVITEMW item;
+    item.iItem = i;
+    item.pszText = name;
+    item.cchTextMax = kSize;
+    item.iSubItem = 0;
+    item.mask = LVIF_TEXT | LVIF_PARAM;
+    if (!_listView.GetItem(&item))
+      continue;
+    int realIndex = GetRealIndex(item);
+    if (realIndex == kParentIndex)
+      continue;
+    if (_selectedStatusVector[realIndex])
+      selectedNames.Add(item.pszText);
+  }
+  */
+  selectedNames.Sort();
+}
+
+void CPanel::SaveSelectedState(CSelectedState &s)
+{
+  s.FocusedName_Defined = false;
+  s.FocusedName.Empty();
+  s.SelectFocused = true; // false;
+  s.SelectedNames.Clear();
+  s.FocusedItem = _listView.GetFocusedItem();
+  {
+    if (s.FocusedItem >= 0)
+    {
+      int realIndex = GetRealItemIndex(s.FocusedItem);
+      if (realIndex != kParentIndex)
+      {
+        s.FocusedName = GetItemRelPath(realIndex);
+        s.FocusedName_Defined = true;
+
+        s.SelectFocused = _listView.IsItemSelected(s.FocusedItem);
+
+        /*
+        const int kSize = 1024;
+        WCHAR name[kSize + 1];
+        LVITEMW item;
+        item.iItem = focusedItem;
+        item.pszText = name;
+        item.cchTextMax = kSize;
+        item.iSubItem = 0;
+        item.mask = LVIF_TEXT;
+        if (_listView.GetItem(&item))
+        focusedName = item.pszText;
+        */
+      }
+    }
+  }
+  GetSelectedNames(s.SelectedNames);
+}
+
+/*
+HRESULT CPanel::RefreshListCtrl(const CSelectedState &s)
+{
+  bool selectFocused = s.SelectFocused;
+  if (_mySelectMode)
+    selectFocused = true;
+  return RefreshListCtrl2(
+      s.FocusedItem >= 0, // allowEmptyFocusedName
+      s.FocusedName, s.FocusedItem, selectFocused, s.SelectedNames);
+}
+*/
+
+HRESULT CPanel::RefreshListCtrl_SaveFocused()
+{
+  CSelectedState state;
+  SaveSelectedState(state);
+  return RefreshListCtrl(state);
+}
+
+void CPanel::SetFocusedSelectedItem(int index, bool select)
+{
+  UINT state = LVIS_FOCUSED;
+  if (select)
+    state |= LVIS_SELECTED;
+  _listView.SetItemState(index, state, state);
+  if (!_mySelectMode && select)
+  {
+    int realIndex = GetRealItemIndex(index);
+    if (realIndex != kParentIndex)
+      _selectedStatusVector[realIndex] = true;
+  }
+}
+
+// #define PRINT_STAT
+
+#ifdef PRINT_STAT
+  void Print_OnNotify(const char *name);
+#else
+  #define Print_OnNotify(x)
+#endif
+
+
+  
+/*
+
+extern UInt32 g_NumGroups;
+extern DWORD g_start_tick;
+extern DWORD g_prev_tick;
+extern DWORD g_Num_SetItemText;
+extern UInt32 g_NumMessages;
+*/
+
+HRESULT CPanel::RefreshListCtrl(const CSelectedState &state)
+{
+  if (!_folder)
+    return S_OK;
+
+  /*
+  g_start_tick = GetTickCount();
+  g_Num_SetItemText = 0;
+  g_NumMessages = 0;
+  */
+
+  _dontShowMode = false;
+  LoadFullPathAndShow();
+  // OutputDebugStringA("=======\n");
+  // OutputDebugStringA("s1 \n");
+  CDisableTimerProcessing timerProcessing(*this);
+  CDisableNotify disableNotify(*this);
+
+  int focusedPos = state.FocusedItem;
+  if (focusedPos < 0)
+    focusedPos = 0;
+
+  _listView.SetRedraw(false);
+  // m_RedrawEnabled = false;
+
+  LVITEMW item;
+  ZeroMemory(&item, sizeof(item));
+  
+  // DWORD tickCount0 = GetTickCount();
+  
+  // _enableItemChangeNotify = false;
+  DeleteListItems();
+  _enableItemChangeNotify = true;
+
+  int listViewItemCount = 0;
+
+  _selectedStatusVector.Clear();
+  // _realIndices.Clear();
+  _startGroupSelect = 0;
+
+  _selectionIsDefined = false;
+  
+  // m_Files.Clear();
+
+  if (!_folder)
+  {
+    // throw 1;
+    SetToRootFolder();
+  }
+  
+  _headerToolBar.EnableButton(kParentFolderID, !IsRootFolder());
+
+  {
+    CMyComPtr<IFolderSetFlatMode> folderSetFlatMode;
+    _folder.QueryInterface(IID_IFolderSetFlatMode, &folderSetFlatMode);
+    if (folderSetFlatMode)
+      folderSetFlatMode->SetFlatMode(BoolToInt(_flatMode));
+  }
+
+  /*
+  {
+    CMyComPtr<IFolderSetShowNtfsStreamsMode> setShow;
+    _folder.QueryInterface(IID_IFolderSetShowNtfsStreamsMode, &setShow);
+    if (setShow)
+      setShow->SetShowNtfsStreamsMode(BoolToInt(_showNtfsStrems_Mode));
+  }
+  */
+
+  // DWORD tickCount1 = GetTickCount();
+  RINOK(_folder->LoadItems());
+  // DWORD tickCount2 = GetTickCount();
+  RINOK(InitColumns());
+
+  // OutputDebugString(TEXT("Start Dir\n"));
+  UInt32 numItems;
+  _folder->GetNumberOfItems(&numItems);
+
+  bool showDots = _showDots && !IsRootFolder();
+
+  _listView.SetItemCount(numItems + (showDots ? 1 : 0));
+
+  _selectedStatusVector.ClearAndReserve(numItems);
+  int cursorIndex = -1;
+
+  CMyComPtr<IFolderGetSystemIconIndex> folderGetSystemIconIndex;
+  if (!Is_Slow_Icon_Folder() || _showRealFileIcons)
+    _folder.QueryInterface(IID_IFolderGetSystemIconIndex, &folderGetSystemIconIndex);
+
+  if (!IsFSFolder())
+  {
+    CMyComPtr<IGetFolderArcProps> getFolderArcProps;
+    _folder.QueryInterface(IID_IGetFolderArcProps, &getFolderArcProps);
+    _thereAreDeletedItems = false;
+    if (getFolderArcProps)
+    {
+      CMyComPtr<IFolderArcProps> arcProps;
+      getFolderArcProps->GetFolderArcProps(&arcProps);
+      if (arcProps)
+      {
+        UInt32 numLevels;
+        if (arcProps->GetArcNumLevels(&numLevels) != S_OK)
+          numLevels = 0;
+        NCOM::CPropVariant prop;
+        if (arcProps->GetArcProp(numLevels - 1, kpidIsDeleted, &prop) == S_OK)
+          if (prop.vt == VT_BOOL && VARIANT_BOOLToBool(prop.boolVal))
+            _thereAreDeletedItems = true;
+      }
+    }
+  }
+
+  _thereAre_ListView_Items = true;
+
+  // OutputDebugStringA("\n\n");
+
+  Print_OnNotify("===== Before Load");
+
+  // #define USE_EMBED_ITEM
+
+  if (showDots)
+  {
+    UString itemName ("..");
+    item.iItem = listViewItemCount;
+    if (itemName == state.FocusedName)
+      cursorIndex = listViewItemCount;
+    item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
+    int subItem = 0;
+    item.iSubItem = subItem++;
+    item.lParam = kParentIndex;
+    #ifdef USE_EMBED_ITEM
+    item.pszText = const_cast<wchar_t *>((const wchar_t *)itemName);
+    #else
+    item.pszText = LPSTR_TEXTCALLBACKW;
+    #endif
+    UInt32 attrib = FILE_ATTRIBUTE_DIRECTORY;
+    item.iImage = _extToIconMap.GetIconIndex(attrib, itemName);
+    if (item.iImage < 0)
+      item.iImage = 0;
+    if (_listView.InsertItem(&item) == -1)
+      return E_FAIL;
+    listViewItemCount++;
+  }
+  
+  // OutputDebugStringA("S1\n");
+
+  UString correctedName;
+  UString itemName;
+  UString relPath;
+  
+  for (UInt32 i = 0; i < numItems; i++)
+  {
+    const wchar_t *name = NULL;
+    unsigned nameLen = 0;
+    
+    if (_folderGetItemName)
+      _folderGetItemName->GetItemName(i, &name, &nameLen);
+    if (!name)
+    {
+      GetItemName(i, itemName);
+      name = itemName;
+      nameLen = itemName.Len();
+    }
+  
+    bool selected = false;
+    
+    if (state.FocusedName_Defined || !state.SelectedNames.IsEmpty())
+    {
+      relPath.Empty();
+      // relPath += GetItemPrefix(i);
+      if (_flatMode)
+      {
+        const wchar_t *prefix = NULL;
+        if (_folderGetItemName)
+        {
+          unsigned prefixLen = 0;
+          _folderGetItemName->GetItemPrefix(i, &prefix, &prefixLen);
+          if (prefix)
+            relPath = prefix;
+        }
+        if (!prefix)
+        {
+          NCOM::CPropVariant prop;
+          if (_folder->GetProperty(i, kpidPrefix, &prop) != S_OK)
+            throw 2723400;
+          if (prop.vt == VT_BSTR)
+            relPath.SetFromBstr(prop.bstrVal);
+        }
+      }
+      relPath += name;
+      if (relPath == state.FocusedName)
+        cursorIndex = listViewItemCount;
+      if (state.SelectedNames.FindInSorted(relPath) >= 0)
+        selected = true;
+    }
+    
+    _selectedStatusVector.AddInReserved(selected);
+
+    item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
+
+    if (!_mySelectMode)
+      if (selected)
+      {
+        item.mask |= LVIF_STATE;
+        item.state = LVIS_SELECTED;
+      }
+  
+    int subItem = 0;
+    item.iItem = listViewItemCount;
+    
+    item.iSubItem = subItem++;
+    item.lParam = i;
+    
+    /*
+    int finish = nameLen - 4;
+    int j;
+    for (j = 0; j < finish; j++)
+    {
+      if (name[j    ] == ' ' &&
+          name[j + 1] == ' ' &&
+          name[j + 2] == ' ' &&
+          name[j + 3] == ' ' &&
+          name[j + 4] == ' ')
+        break;
+    }
+    if (j < finish)
+    {
+      correctedName.Empty();
+      correctedName = "virus";
+      int pos = 0;
+      for (;;)
+      {
+        int posNew = itemName.Find(L"     ", pos);
+        if (posNew < 0)
+        {
+          correctedName += itemName.Ptr(pos);
+          break;
+        }
+        correctedName += itemName.Mid(pos, posNew - pos);
+        correctedName += " ... ";
+        pos = posNew;
+        while (itemName[++pos] == ' ');
+      }
+      item.pszText = const_cast<wchar_t *>((const wchar_t *)correctedName);
+    }
+    else
+    */
+    {
+      #ifdef USE_EMBED_ITEM
+      item.pszText = const_cast<wchar_t *>((const wchar_t *)name);
+      #else
+      item.pszText = LPSTR_TEXTCALLBACKW;
+      #endif
+      /* LPSTR_TEXTCALLBACKW works, but in some cases there are problems,
+      since we block notify handler.
+      LPSTR_TEXTCALLBACKW can be 2-3 times faster for loading in this loop. */
+    }
+
+    bool defined = false;
+  
+    if (folderGetSystemIconIndex)
+    {
+      folderGetSystemIconIndex->GetSystemIconIndex(i, &item.iImage);
+      defined = (item.iImage > 0);
+    }
+
+    if (!defined)
+    {
+      UInt32 attrib = 0;
+      {
+        NCOM::CPropVariant prop;
+        RINOK(_folder->GetProperty(i, kpidAttrib, &prop));
+        if (prop.vt == VT_UI4)
+          attrib = prop.ulVal;
+      }
+      if (IsItem_Folder(i))
+        attrib |= FILE_ATTRIBUTE_DIRECTORY;
+
+      if (_currentFolderPrefix.IsEmpty())
+      {
+        int iconIndexTemp;
+        GetRealIconIndex(us2fs((UString)name) + FCHAR_PATH_SEPARATOR, attrib, iconIndexTemp);
+        item.iImage = iconIndexTemp;
+      }
+      else
+      {
+        item.iImage = _extToIconMap.GetIconIndex(attrib, name);
+      }
+    }
+    
+    if (item.iImage < 0)
+      item.iImage = 0;
+
+    if (_listView.InsertItem(&item) == -1)
+      return E_FAIL;
+    listViewItemCount++;
+  }
+  
+  /*
+    xp-64: there is different order when Windows calls CPanel::OnNotify for _listView modes:
+    Details      : after whole code
+    List         : 2 times:
+                        1) - ListView.SotRedraw()
+                        2) - after whole code
+    Small Icons  :
+    Large icons  : 2 times:
+                        1) - ListView.Sort()
+                        2) - after whole code (calls with reverse order of items)
+
+    So we need to allow Notify(), when windows requests names during the following code.
+  */
+
+  Print_OnNotify("after Load");
+
+  disableNotify.SetMemMode_Enable();
+  disableNotify.Restore();
+
+  if (_listView.GetItemCount() > 0 && cursorIndex >= 0)
+    SetFocusedSelectedItem(cursorIndex, state.SelectFocused);
+
+  Print_OnNotify("after SetFocusedSelectedItem");
+  
+  SetSortRawStatus();
+  _listView.SortItems(CompareItems, (LPARAM)this);
+  
+  Print_OnNotify("after  Sort");
+
+  if (cursorIndex < 0 && _listView.GetItemCount() > 0)
+  {
+    if (focusedPos >= _listView.GetItemCount())
+      focusedPos = _listView.GetItemCount() - 1;
+    // we select item only in showDots mode.
+    SetFocusedSelectedItem(focusedPos, showDots && (focusedPos == 0));
+  }
+
+  // m_RedrawEnabled = true;
+  
+  Print_OnNotify("after  SetFocusedSelectedItem2");
+
+  _listView.EnsureVisible(_listView.GetFocusedItem(), false);
+
+  // disableNotify.SetMemMode_Enable();
+  // disableNotify.Restore();
+
+  Print_OnNotify("after  EnsureVisible");
+
+  _listView.SetRedraw(true);
+
+  Print_OnNotify("after  SetRedraw");
+
+  _listView.InvalidateRect(NULL, true);
+  
+  Print_OnNotify("after InvalidateRect");
+  /*
+  _listView.UpdateWindow();
+  */
+  Refresh_StatusBar();
+  /*
+  char s[256];
+  sprintf(s,
+      // "attribMap = %5d, extMap = %5d, "
+      "delete = %5d, load = %5d, list = %5d, sort = %5d, end = %5d",
+      // _extToIconMap._attribMap.Size(),
+      // _extToIconMap._extMap.Size(),
+      tickCount1 - tickCount0,
+      tickCount2 - tickCount1,
+      tickCount3 - tickCount2,
+      tickCount4 - tickCount3,
+      tickCount5 - tickCount4
+      );
+  sprintf(s,
+      "5 = %5d, 6 = %5d, 7 = %5d, 8 = %5d, 9 = %5d",
+      tickCount5 - tickCount4,
+      tickCount6 - tickCount5,
+      tickCount7 - tickCount6,
+      tickCount8 - tickCount7,
+      tickCount9 - tickCount8
+      );
+  OutputDebugStringA(s);
+  */
+  return S_OK;
+}
+
+
+void CPanel::GetSelectedItemsIndices(CRecordVector<UInt32> &indices) const
+{
+  indices.Clear();
+  /*
+  int itemIndex = -1;
+  while ((itemIndex = _listView.GetNextSelectedItem(itemIndex)) != -1)
+  {
+    LPARAM param;
+    if (_listView.GetItemParam(itemIndex, param))
+      indices.Add(param);
+  }
+  HeapSort(&indices.Front(), indices.Size());
+  */
+  const bool *v = &_selectedStatusVector.Front();
+  unsigned size = _selectedStatusVector.Size();
+  for (unsigned i = 0; i < size; i++)
+    if (v[i])
+      indices.Add(i);
+}
+
+
+void CPanel::GetOperatedItemIndices(CRecordVector<UInt32> &indices) const
+{
+  GetSelectedItemsIndices(indices);
+  if (!indices.IsEmpty())
+    return;
+  if (_listView.GetSelectedCount() == 0)
+    return;
+  int focusedItem = _listView.GetFocusedItem();
+  if (focusedItem >= 0)
+  {
+    if (_listView.IsItemSelected(focusedItem))
+    {
+      int realIndex = GetRealItemIndex(focusedItem);
+      if (realIndex != kParentIndex)
+        indices.Add(realIndex);
+    }
+  }
+}
+
+void CPanel::GetAllItemIndices(CRecordVector<UInt32> &indices) const
+{
+  indices.Clear();
+  UInt32 numItems;
+  if (_folder->GetNumberOfItems(&numItems) == S_OK)
+    for (UInt32 i = 0; i < numItems; i++)
+      indices.Add(i);
+}
+
+void CPanel::GetOperatedIndicesSmart(CRecordVector<UInt32> &indices) const
+{
+  GetOperatedItemIndices(indices);
+  if (indices.IsEmpty() || (indices.Size() == 1 && indices[0] == (UInt32)(Int32)-1))
+    GetAllItemIndices(indices);
+}
+
+/*
+void CPanel::GetOperatedListViewIndices(CRecordVector<UInt32> &indices) const
+{
+  indices.Clear();
+  int numItems = _listView.GetItemCount();
+  for (int i = 0; i < numItems; i++)
+  {
+    int realIndex = GetRealItemIndex(i);
+    if (realIndex >= 0)
+      if (_selectedStatusVector[realIndex])
+        indices.Add(i);
+  }
+  if (indices.IsEmpty())
+  {
+    int focusedItem = _listView.GetFocusedItem();
+      if (focusedItem >= 0)
+        indices.Add(focusedItem);
+  }
+}
+*/
+
+void CPanel::EditItem(bool useEditor)
+{
+  if (!useEditor)
+  {
+    CMyComPtr<IFolderCalcItemFullSize> calcItemFullSize;
+    _folder.QueryInterface(IID_IFolderCalcItemFullSize, &calcItemFullSize);
+    if (calcItemFullSize)
+    {
+      bool needRefresh = false;
+      CRecordVector<UInt32> indices;
+      GetOperatedItemIndices(indices);
+      FOR_VECTOR (i, indices)
+      {
+        UInt32 index = indices[i];
+        if (IsItem_Folder(index))
+        {
+          calcItemFullSize->CalcItemFullSize(index, NULL);
+          needRefresh = true;
+        }
+      }
+      if (needRefresh)
+      {
+        // _listView.RedrawItem(0);
+        // _listView.RedrawAllItems();
+        InvalidateList();
+        return;
+      }
+    }
+  }
+
+
+  int focusedItem = _listView.GetFocusedItem();
+  if (focusedItem < 0)
+    return;
+  int realIndex = GetRealItemIndex(focusedItem);
+  if (realIndex == kParentIndex)
+    return;
+  if (!IsItem_Folder(realIndex))
+    EditItem(realIndex, useEditor);
+}
+
+void CPanel::OpenFocusedItemAsInternal(const wchar_t *type)
+{
+  int focusedItem = _listView.GetFocusedItem();
+  if (focusedItem < 0)
+    return;
+  int realIndex = GetRealItemIndex(focusedItem);
+  if (IsItem_Folder(realIndex))
+    OpenFolder(realIndex);
+  else
+    OpenItem(realIndex, true, false, type);
+}
+
+void CPanel::OpenSelectedItems(bool tryInternal)
+{
+  CRecordVector<UInt32> indices;
+  GetOperatedItemIndices(indices);
+  if (indices.Size() > 20)
+  {
+    MessageBox_Error_LangID(IDS_TOO_MANY_ITEMS);
+    return;
+  }
+  
+  int focusedItem = _listView.GetFocusedItem();
+  if (focusedItem >= 0)
+  {
+    int realIndex = GetRealItemIndex(focusedItem);
+    if (realIndex == kParentIndex && (tryInternal || indices.Size() == 0) && _listView.IsItemSelected(focusedItem))
+      indices.Insert(0, realIndex);
+  }
+
+  bool dirIsStarted = false;
+  FOR_VECTOR (i, indices)
+  {
+    UInt32 index = indices[i];
+    // CFileInfo &aFile = m_Files[index];
+    if (IsItem_Folder(index))
+    {
+      if (!dirIsStarted)
+      {
+        if (tryInternal)
+        {
+          OpenFolder(index);
+          dirIsStarted = true;
+          break;
+        }
+        else
+          OpenFolderExternal(index);
+      }
+    }
+    else
+      OpenItem(index, (tryInternal && indices.Size() == 1), true);
+  }
+}
+
+UString CPanel::GetItemName(int itemIndex) const
+{
+  if (itemIndex == kParentIndex)
+    return L"..";
+  NCOM::CPropVariant prop;
+  if (_folder->GetProperty(itemIndex, kpidName, &prop) != S_OK)
+    throw 2723400;
+  if (prop.vt != VT_BSTR)
+    throw 2723401;
+  return prop.bstrVal;
+}
+
+UString CPanel::GetItemName_for_Copy(int itemIndex) const
+{
+  if (itemIndex == kParentIndex)
+    return L"..";
+  UString s;
+  {
+    NCOM::CPropVariant prop;
+    if (_folder->GetProperty(itemIndex, kpidOutName, &prop) == S_OK)
+    {
+      if (prop.vt == VT_BSTR)
+        s = prop.bstrVal;
+      else if (prop.vt != VT_EMPTY)
+        throw 2723401;
+    }
+    if (s.IsEmpty())
+      s = GetItemName(itemIndex);
+  }
+  return Get_Correct_FsFile_Name(s);
+}
+
+void CPanel::GetItemName(int itemIndex, UString &s) const
+{
+  if (itemIndex == kParentIndex)
+  {
+    s = "..";
+    return;
+  }
+  NCOM::CPropVariant prop;
+  if (_folder->GetProperty(itemIndex, kpidName, &prop) != S_OK)
+    throw 2723400;
+  if (prop.vt != VT_BSTR)
+    throw 2723401;
+  s.SetFromBstr(prop.bstrVal);
+}
+
+UString CPanel::GetItemPrefix(int itemIndex) const
+{
+  if (itemIndex == kParentIndex)
+    return UString();
+  NCOM::CPropVariant prop;
+  if (_folder->GetProperty(itemIndex, kpidPrefix, &prop) != S_OK)
+    throw 2723400;
+  UString prefix;
+  if (prop.vt == VT_BSTR)
+    prefix.SetFromBstr(prop.bstrVal);
+  return prefix;
+}
+
+UString CPanel::GetItemRelPath(int itemIndex) const
+{
+  return GetItemPrefix(itemIndex) + GetItemName(itemIndex);
+}
+
+UString CPanel::GetItemRelPath2(int itemIndex) const
+{
+  UString s = GetItemRelPath(itemIndex);
+  #if defined(_WIN32) && !defined(UNDER_CE)
+  if (s.Len() == 2 && NFile::NName::IsDrivePath2(s))
+  {
+    if (IsFSDrivesFolder() && !IsDeviceDrivesPrefix())
+      s.Add_PathSepar();
+  }
+  #endif
+  return s;
+}
+
+UString CPanel::GetItemFullPath(int itemIndex) const
+{
+  return GetFsPath() + GetItemRelPath2(itemIndex);
+}
+
+bool CPanel::GetItem_BoolProp(UInt32 itemIndex, PROPID propID) const
+{
+  NCOM::CPropVariant prop;
+  if (_folder->GetProperty(itemIndex, propID, &prop) != S_OK)
+    throw 2723400;
+  if (prop.vt == VT_BOOL)
+    return VARIANT_BOOLToBool(prop.boolVal);
+  if (prop.vt == VT_EMPTY)
+    return false;
+  throw 2723401;
+}
+
+bool CPanel::IsItem_Deleted(int itemIndex) const
+{
+  if (itemIndex == kParentIndex)
+    return false;
+  return GetItem_BoolProp(itemIndex, kpidIsDeleted);
+}
+
+bool CPanel::IsItem_Folder(int itemIndex) const
+{
+  if (itemIndex == kParentIndex)
+    return true;
+  return GetItem_BoolProp(itemIndex, kpidIsDir);
+}
+
+bool CPanel::IsItem_AltStream(int itemIndex) const
+{
+  if (itemIndex == kParentIndex)
+    return false;
+  return GetItem_BoolProp(itemIndex, kpidIsAltStream);
+}
+
+UInt64 CPanel::GetItem_UInt64Prop(int itemIndex, PROPID propID) const
+{
+  if (itemIndex == kParentIndex)
+    return 0;
+  NCOM::CPropVariant prop;
+  if (_folder->GetProperty(itemIndex, propID, &prop) != S_OK)
+    throw 2723400;
+  UInt64 val = 0;
+  if (ConvertPropVariantToUInt64(prop, val))
+    return val;
+  return 0;
+}
+
+UInt64 CPanel::GetItemSize(int itemIndex) const
+{
+  if (itemIndex == kParentIndex)
+    return 0;
+  if (_folderGetItemName)
+    return _folderGetItemName->GetItemSize(itemIndex);
+  return GetItem_UInt64Prop(itemIndex, kpidSize);
+}
+
+void CPanel::SaveListViewInfo()
+{
+  if (!_needSaveInfo)
+    return;
+
+  unsigned i;
+  
+  for (i = 0; i < _visibleColumns.Size(); i++)
+  {
+    CPropColumn &prop = _visibleColumns[i];
+    LVCOLUMN winColumnInfo;
+    winColumnInfo.mask = LVCF_ORDER | LVCF_WIDTH;
+    if (!_listView.GetColumn(i, &winColumnInfo))
+      throw 1;
+    prop.Order = winColumnInfo.iOrder;
+    prop.Width = winColumnInfo.cx;
+  }
+
+  CListViewInfo viewInfo;
+  
+  // PROPID sortPropID = _columns[_sortIndex].ID;
+  PROPID sortPropID = _sortID;
+  
+  // we save columns as "sorted by order" to registry
+
+  CPropColumns sortedProperties = _visibleColumns;
+
+  sortedProperties.Sort();
+  
+  for (i = 0; i < sortedProperties.Size(); i++)
+  {
+    const CPropColumn &prop = sortedProperties[i];
+    CColumnInfo columnInfo;
+    columnInfo.IsVisible = prop.IsVisible;
+    columnInfo.PropID = prop.ID;
+    columnInfo.Width = prop.Width;
+    viewInfo.Columns.Add(columnInfo);
+  }
+  
+  for (i = 0; i < _columns.Size(); i++)
+  {
+    const CPropColumn &prop = _columns[i];
+    if (sortedProperties.FindItem_for_PropID(prop.ID) < 0)
+    {
+      CColumnInfo columnInfo;
+      columnInfo.IsVisible = false;
+      columnInfo.PropID = prop.ID;
+      columnInfo.Width = prop.Width;
+      viewInfo.Columns.Add(columnInfo);
+    }
+  }
+  
+  viewInfo.SortID = sortPropID;
+  viewInfo.Ascending = _ascending;
+  viewInfo.IsLoaded = true;
+  if (!_listViewInfo.IsEqual(viewInfo))
+  {
+    viewInfo.Save(_typeIDString);
+    _listViewInfo = viewInfo;
+  }
+}
+
+
+bool CPanel::OnRightClick(MY_NMLISTVIEW_NMITEMACTIVATE *itemActiveate, LRESULT &result)
+{
+  if (itemActiveate->hdr.hwndFrom == HWND(_listView))
+    return false;
+  POINT point;
+  ::GetCursorPos(&point);
+  ShowColumnsContextMenu(point.x, point.y);
+  result = TRUE;
+  return true;
+}
+
+void CPanel::ShowColumnsContextMenu(int x, int y)
+{
+  CMenu menu;
+  CMenuDestroyer menuDestroyer(menu);
+
+  menu.CreatePopup();
+
+  const int kCommandStart = 100;
+  FOR_VECTOR (i, _columns)
+  {
+    const CPropColumn &prop = _columns[i];
+    UINT flags =  MF_STRING;
+    if (prop.IsVisible)
+      flags |= MF_CHECKED;
+    if (i == 0)
+      flags |= MF_GRAYED;
+    menu.AppendItem(flags, kCommandStart + i, prop.Name);
+  }
+  
+  int menuResult = menu.Track(TPM_LEFTALIGN | TPM_RETURNCMD | TPM_NONOTIFY, x, y, _listView);
+  
+  if (menuResult >= kCommandStart && menuResult <= kCommandStart + (int)_columns.Size())
+  {
+    int index = menuResult - kCommandStart;
+    CPropColumn &prop = _columns[index];
+    prop.IsVisible = !prop.IsVisible;
+
+    if (prop.IsVisible)
+    {
+      prop.Order = _visibleColumns.Size();
+      AddColumn(prop);
+    }
+    else
+    {
+      int visibleIndex = _visibleColumns.FindItem_for_PropID(prop.ID);
+      if (visibleIndex >= 0)
+      {
+        /*
+        if (_sortIndex == index)
+        {
+        _sortIndex = 0;
+        _ascending = true;
+        }
+        */
+        if (_sortID == prop.ID)
+        {
+          _sortID = kpidName;
+          _ascending = true;
+        }
+        DeleteColumn(visibleIndex);
+      }
+    }
+  }
+}
+
+void CPanel::OnReload()
+{
+  HRESULT res = RefreshListCtrl_SaveFocused();
+  if (res != S_OK)
+    MessageBox_Error_HRESULT(res);
+}
+
+void CPanel::OnTimer()
+{
+  if (!_processTimer)
+    return;
+  if (!AutoRefresh_Mode)
+    return;
+  CMyComPtr<IFolderWasChanged> folderWasChanged;
+  if (_folder.QueryInterface(IID_IFolderWasChanged, &folderWasChanged) != S_OK)
+    return;
+  Int32 wasChanged;
+  if (folderWasChanged->WasChanged(&wasChanged) != S_OK)
+    return;
+  if (wasChanged == 0)
+    return;
+  OnReload();
+}
diff --git a/CPP/7zip/UI/FileManager/PanelKey.cpp b/CPP/7zip/UI/FileManager/PanelKey.cpp
new file mode 100644
index 0000000..3ab478e
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelKey.cpp
@@ -0,0 +1,347 @@
+// PanelKey.cpp
+
+#include "StdAfx.h"
+
+#include "Panel.h"
+#include "HelpUtils.h"
+
+#include "../../PropID.h"
+#include "App.h"
+
+using namespace NWindows;
+
+// #define kHelpTopic "FM/index.htm"
+
+struct CVKeyPropIDPair
+{
+  WORD VKey;
+  PROPID PropID;
+};
+
+static const CVKeyPropIDPair g_VKeyPropIDPairs[] =
+{
+  { VK_F3, kpidName },
+  { VK_F4, kpidExtension },
+  { VK_F5, kpidMTime },
+  { VK_F6, kpidSize },
+  { VK_F7, kpidNoProperty }
+};
+
+static int FindVKeyPropIDPair(WORD vKey)
+{
+  for (unsigned i = 0; i < ARRAY_SIZE(g_VKeyPropIDPairs); i++)
+    if (g_VKeyPropIDPairs[i].VKey == vKey)
+      return i;
+  return -1;
+}
+
+
+bool CPanel::OnKeyDown(LPNMLVKEYDOWN keyDownInfo, LRESULT &result)
+{
+  if (keyDownInfo->wVKey == VK_TAB && keyDownInfo->hdr.hwndFrom == _listView)
+  {
+    _panelCallback->OnTab();
+    return false;
+  }
+  bool alt = IsKeyDown(VK_MENU);
+  bool ctrl = IsKeyDown(VK_CONTROL);
+  // bool leftCtrl = IsKeyDown(VK_LCONTROL);
+  bool rightCtrl = IsKeyDown(VK_RCONTROL);
+  bool shift = IsKeyDown(VK_SHIFT);
+  result = 0;
+
+  if (keyDownInfo->wVKey >= '0' && keyDownInfo->wVKey <= '9' &&
+      (rightCtrl || alt))
+  {
+    int index = keyDownInfo->wVKey - '0';
+    if (shift)
+    {
+      SetBookmark(index);
+      return true;
+    }
+    else
+    {
+      OpenBookmark(index);
+      return true;
+    }
+  }
+
+  if ((keyDownInfo->wVKey == VK_F2 ||
+    keyDownInfo->wVKey == VK_F1) && alt && !ctrl && !shift)
+  {
+    _panelCallback->SetFocusToPath(keyDownInfo->wVKey == VK_F1 ? 0 : 1);
+    return true;
+  }
+
+  if ((keyDownInfo->wVKey == VK_F9) && !alt && !ctrl && !shift)
+  {
+    g_App.SwitchOnOffOnePanel();
+  }
+
+  if (keyDownInfo->wVKey >= VK_F3 && keyDownInfo->wVKey <= VK_F12 && ctrl)
+  {
+    int index = FindVKeyPropIDPair(keyDownInfo->wVKey);
+    if (index >= 0)
+      SortItemsWithPropID(g_VKeyPropIDPairs[index].PropID);
+  }
+
+  switch (keyDownInfo->wVKey)
+  {
+    case VK_SHIFT:
+    {
+      _selectionIsDefined = false;
+      _prevFocusedItem = _listView.GetFocusedItem();
+      break;
+    }
+    /*
+    case VK_F1:
+    {
+      // ShowHelpWindow(NULL, kHelpTopic);
+      break;
+    }
+    */
+    case VK_F2:
+    {
+      if (!alt && !ctrl &&!shift)
+      {
+        RenameFile();
+        return true;
+      }
+      break;
+    }
+    case VK_F3:
+    {
+      if (!alt && !ctrl && !shift)
+      {
+        EditItem(false);
+        return true;
+      }
+      break;
+    }
+    case VK_F4:
+    {
+      if (!alt && !ctrl && !shift)
+      {
+        EditItem(true);
+        return true;
+      }
+      if (!alt && !ctrl && shift)
+      {
+        CreateFile();
+        return true;
+      }
+      break;
+    }
+    case VK_F5:
+    {
+      if (!alt && !ctrl)
+      {
+        _panelCallback->OnCopy(false, shift);
+        return true;
+      }
+      break;
+    }
+    case VK_F6:
+    {
+      if (!alt && !ctrl)
+      {
+        _panelCallback->OnCopy(true, shift);
+        return true;
+      }
+      break;
+    }
+    case VK_F7:
+    {
+      if (!alt && !ctrl && !shift)
+      {
+        /* we can process F7 via menu ACCELERATOR.
+          But menu loading can be slow in case of UNC paths and system menu.
+          So we use don't use ACCELERATOR */
+        CreateFolder();
+        return true;
+      }
+      break;
+    }
+    case VK_DELETE:
+    {
+      DeleteItems(!shift);
+      return true;
+    }
+    case VK_INSERT:
+    {
+      if (!alt)
+      {
+        if (ctrl && !shift)
+        {
+          EditCopy();
+          return true;
+        }
+        if (shift && !ctrl)
+        {
+          EditPaste();
+          return true;
+        }
+        if (!shift && !ctrl && _mySelectMode)
+        {
+          OnInsert();
+          return true;
+        }
+      }
+      return false;
+    }
+    case VK_DOWN:
+    {
+      if (shift)
+        OnArrowWithShift();
+      return false;
+    }
+    case VK_UP:
+    {
+      if (alt)
+        _panelCallback->OnSetSameFolder();
+      else if (shift)
+        OnArrowWithShift();
+      return false;
+    }
+    case VK_RIGHT:
+    {
+      if (alt)
+        _panelCallback->OnSetSubFolder();
+      else if (shift)
+        OnArrowWithShift();
+      return false;
+    }
+    case VK_LEFT:
+    {
+      if (alt)
+        _panelCallback->OnSetSubFolder();
+      else if (shift)
+        OnArrowWithShift();
+      return false;
+    }
+    case VK_NEXT:
+    {
+      if (ctrl && !alt && !shift)
+      {
+        // EnterToFocused();
+        return true;
+      }
+      break;
+    }
+    case VK_ADD:
+    {
+      if (alt)
+        SelectByType(true);
+      else if (shift)
+        SelectAll(true);
+      else if (!ctrl)
+        SelectSpec(true);
+      return true;
+    }
+    case VK_SUBTRACT:
+    {
+      if (alt)
+        SelectByType(false);
+      else if (shift)
+        SelectAll(false);
+      else
+        SelectSpec(false);
+      return true;
+    }
+    /*
+    case VK_DELETE:
+      CommandDelete();
+      return 0;
+    case VK_F1:
+      CommandHelp();
+      return 0;
+    */
+    case VK_BACK:
+      OpenParentFolder();
+      return true;
+    /*
+    case VK_DIVIDE:
+    case '\\':
+    case '/':
+    case VK_OEM_5:
+    {
+      // OpenRootFolder();
+      OpenDrivesFolder();
+
+      return true;
+    }
+    */
+    case 'A':
+      if (ctrl)
+      {
+        SelectAll(true);
+        return true;
+      }
+      return false;
+    case 'X':
+      if (ctrl)
+      {
+        EditCut();
+        return true;
+      }
+      return false;
+    case 'C':
+      if (ctrl)
+      {
+        EditCopy();
+        return true;
+      }
+      return false;
+    case 'V':
+      if (ctrl)
+      {
+        EditPaste();
+        return true;
+      }
+      return false;
+    case 'N':
+      if (ctrl)
+      {
+        CreateFile();
+        return true;
+      }
+      return false;
+    case 'R':
+      if (ctrl)
+      {
+        OnReload();
+        return true;
+      }
+      return false;
+    case 'Z':
+      if (ctrl)
+      {
+        ChangeComment();
+        return true;
+      }
+      return false;
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+      if (ctrl)
+      {
+        int styleIndex = keyDownInfo->wVKey - '1';
+        SetListViewMode(styleIndex);
+        return true;
+      }
+      return false;
+    case VK_MULTIPLY:
+      {
+        InvertSelection();
+        return true;
+      }
+    case VK_F12:
+      if (alt && !ctrl && !shift)
+      {
+        FoldersHistory();
+        return true;
+      }
+  }
+  return false;
+}
diff --git a/CPP/7zip/UI/FileManager/PanelListNotify.cpp b/CPP/7zip/UI/FileManager/PanelListNotify.cpp
new file mode 100644
index 0000000..d2114f1
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelListNotify.cpp
@@ -0,0 +1,860 @@
+// PanelListNotify.cpp
+
+#include "StdAfx.h"
+
+#include "resource.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#include "../Common/PropIDUtils.h"
+#include "../../PropID.h"
+
+#include "App.h"
+#include "Panel.h"
+#include "FormatUtils.h"
+
+using namespace NWindows;
+
+/* Unicode characters for space:
+0x009C STRING TERMINATOR
+0x00B7 Middle dot
+0x237D Shouldered open box
+0x2420 Symbol for space
+0x2422 Blank symbol
+0x2423 Open box
+*/
+
+#define SPACE_REPLACE_CHAR (wchar_t)(0x2423)
+#define SPACE_TERMINATOR_CHAR (wchar_t)(0x9C)
+
+#define INT_TO_STR_SPEC(v) \
+  while (v >= 10) { temp[i++] = (unsigned char)('0' + (unsigned)(v % 10)); v /= 10; } \
+  *s++ = (unsigned char)('0' + (unsigned)v);
+
+static void ConvertSizeToString(UInt64 val, wchar_t *s) throw()
+{
+  unsigned char temp[32];
+  unsigned i = 0;
+  
+  if (val <= (UInt32)0xFFFFFFFF)
+  {
+    UInt32 val32 = (UInt32)val;
+    INT_TO_STR_SPEC(val32)
+  }
+  else
+  {
+    INT_TO_STR_SPEC(val)
+  }
+
+  if (i < 3)
+  {
+    if (i != 0)
+    {
+      *s++ = temp[(size_t)i - 1];
+      if (i == 2)
+        *s++ = temp[0];
+    }
+    *s = 0;
+    return;
+  }
+
+  unsigned r = i % 3;
+  if (r != 0)
+  {
+    s[0] = temp[--i];
+    if (r == 2)
+      s[1] = temp[--i];
+    s += r;
+  }
+
+  do
+  {
+    s[0] = ' ';
+    s[1] = temp[(size_t)i - 1];
+    s[2] = temp[(size_t)i - 2];
+    s[3] = temp[(size_t)i - 3];
+    s += 4;
+  }
+  while (i -= 3);
+  
+  *s = 0;
+}
+
+UString ConvertSizeToString(UInt64 value);
+UString ConvertSizeToString(UInt64 value)
+{
+  wchar_t s[32];
+  ConvertSizeToString(value, s);
+  return s;
+}
+
+static inline unsigned GetHex_Upper(unsigned v)
+{
+  return (v < 10) ? ('0' + v) : ('A' + (v - 10));
+}
+
+static inline unsigned GetHex_Lower(unsigned v)
+{
+  return (v < 10) ? ('0' + v) : ('a' + (v - 10));
+}
+
+/*
+static void HexToString(char *dest, const Byte *data, UInt32 size)
+{
+  for (UInt32 i = 0; i < size; i++)
+  {
+    unsigned b = data[i];
+    dest[0] = GetHex((b >> 4) & 0xF);
+    dest[1] = GetHex(b & 0xF);
+    dest += 2;
+  }
+  *dest = 0;
+}
+*/
+
+bool IsSizeProp(UINT propID) throw();
+bool IsSizeProp(UINT propID) throw()
+{
+  switch (propID)
+  {
+    case kpidSize:
+    case kpidPackSize:
+    case kpidNumSubDirs:
+    case kpidNumSubFiles:
+    case kpidOffset:
+    case kpidLinks:
+    case kpidNumBlocks:
+    case kpidNumVolumes:
+    case kpidPhySize:
+    case kpidHeadersSize:
+    case kpidTotalSize:
+    case kpidFreeSpace:
+    case kpidClusterSize:
+    case kpidNumErrors:
+    case kpidNumStreams:
+    case kpidNumAltStreams:
+    case kpidAltStreamsSize:
+    case kpidVirtualSize:
+    case kpidUnpackSize:
+    case kpidTotalPhySize:
+    case kpidTailSize:
+    case kpidEmbeddedStubSize:
+      return true;
+  }
+  return false;
+}
+
+
+
+/*
+#include <stdio.h>
+
+UInt64 GetCpuTicks()
+{
+    #ifdef _WIN64
+      return __rdtsc();
+    #else
+      UInt32 lowVal, highVal;
+      __asm RDTSC;
+      __asm mov lowVal, EAX;
+      __asm mov highVal, EDX;
+      return ((UInt64)highVal << 32) | lowVal;
+    #endif
+}
+
+UInt32 g_NumGroups;
+UInt64 g_start_tick;
+UInt64 g_prev_tick;
+DWORD g_Num_SetItemText;
+UInt32 g_NumMessages;
+*/
+
+LRESULT CPanel::SetItemText(LVITEMW &item)
+{
+  if (_dontShowMode)
+    return 0;
+  UInt32 realIndex = GetRealIndex(item);
+
+  // g_Num_SetItemText++;
+
+  /*
+  if ((item.mask & LVIF_IMAGE) != 0)
+  {
+    bool defined  = false;
+    CComPtr<IFolderGetSystemIconIndex> folderGetSystemIconIndex;
+    _folder.QueryInterface(&folderGetSystemIconIndex);
+    if (folderGetSystemIconIndex)
+    {
+      folderGetSystemIconIndex->GetSystemIconIndex(index, &item.iImage);
+      defined = (item.iImage > 0);
+    }
+    if (!defined)
+    {
+      NCOM::CPropVariant prop;
+      _folder->GetProperty(index, kpidAttrib, &prop);
+      UINT32 attrib = 0;
+      if (prop.vt == VT_UI4)
+        attrib = prop.ulVal;
+      else if (IsItemFolder(index))
+        attrib |= FILE_ATTRIBUTE_DIRECTORY;
+      if (_currentFolderPrefix.IsEmpty())
+        throw 1;
+      else
+        item.iImage = _extToIconMap.GetIconIndex(attrib, GetSystemString(GetItemName(index)));
+    }
+    // item.iImage = 1;
+  }
+  */
+
+  if ((item.mask & LVIF_TEXT) == 0)
+    return 0;
+
+  LPWSTR text = item.pszText;
+
+  if (item.cchTextMax > 0)
+    text[0] = 0;
+
+  if (item.cchTextMax <= 1)
+    return 0;
+  
+  const CPropColumn &property = _visibleColumns[item.iSubItem];
+  PROPID propID = property.ID;
+
+  if (realIndex == kParentIndex_UInt32)
+  {
+    if (propID == kpidName)
+    {
+      if (item.cchTextMax > 2)
+      {
+        text[0] = '.';
+        text[1] = '.';
+        text[2] = 0;
+      }
+    }
+    return 0;
+  }
+
+  /*
+  // List-view in report-view in Windows 10 is slow (50+ ms) for page change.
+  // that code shows the time of page reload for items
+  // if you know how to improve the speed of list view refresh, notify 7-Zip developer
+
+  // if (propID == 2000)
+  // if (propID == kpidName)
+  {
+    // debug column;
+    // DWORD dw = GetCpuTicks();
+    UInt64 dw = GetCpuTicks();
+    UInt64 deltaLast = dw - g_prev_tick;
+    #define conv_ticks(t) ((unsigned)((t) / 100000))
+    if (deltaLast > 1000u * 1000 * 1000)
+    {
+      UInt64 deltaFull = g_prev_tick - g_start_tick;
+      char s[128];
+      sprintf(s, "%d", conv_ticks(deltaFull));
+      OutputDebugStringA(s);
+      g_start_tick = dw;
+      g_NumGroups++;
+    }
+    g_prev_tick = dw;
+    UString u;
+    char s[128];
+    UInt64 deltaFull = dw - g_start_tick;
+    // for (int i = 0; i < 100000; i++)
+    sprintf(s, "%d %d %d-%d ", g_NumMessages, g_Num_SetItemText, g_NumGroups, conv_ticks(deltaFull));
+    // sprintf(s, "%d-%d ", g_NumGroups, conv_ticks(deltaFull));
+    u = s;
+    lstrcpyW(text, u.Ptr());
+    text += u.Len();
+
+    // dw = GetCpuTicks();
+    // deltaFull = dw - g_prev_tick;
+    // sprintf(s, "-%d ", conv_ticks(deltaFull));
+    // u = s;
+    // lstrcpyW(text, u.Ptr());
+    // text += u.Len();
+
+    if (propID != kpidName)
+      return 0;
+  }
+  */
+
+
+  if (property.IsRawProp)
+  {
+    const void *data;
+    UInt32 dataSize;
+    UInt32 propType;
+    RINOK(_folderRawProps->GetRawProp(realIndex, propID, &data, &dataSize, &propType));
+    unsigned limit = item.cchTextMax - 1;
+    if (dataSize == 0)
+    {
+      text[0] = 0;
+      return 0;
+    }
+    
+    if (propID == kpidNtReparse)
+    {
+      UString s;
+      ConvertNtReparseToString((const Byte *)data, dataSize, s);
+      if (!s.IsEmpty())
+      {
+        unsigned i;
+        for (i = 0; i < limit; i++)
+        {
+          wchar_t c = s[i];
+          if (c == 0)
+            break;
+          text[i] = c;
+        }
+        text[i] = 0;
+        return 0;
+      }
+    }
+    else if (propID == kpidNtSecure)
+    {
+      AString s;
+      ConvertNtSecureToString((const Byte *)data, dataSize, s);
+      if (!s.IsEmpty())
+      {
+        unsigned i;
+        for (i = 0; i < limit; i++)
+        {
+          wchar_t c = (Byte)s[i];
+          if (c == 0)
+            break;
+          text[i] = c;
+        }
+        text[i] = 0;
+        return 0;
+      }
+    }
+    {
+      const unsigned kMaxDataSize = 64;
+      if (dataSize > kMaxDataSize)
+      {
+        char temp[32];
+        MyStringCopy(temp, "data:");
+        ConvertUInt32ToString(dataSize, temp + 5);
+        unsigned i;
+        for (i = 0; i < limit; i++)
+        {
+          wchar_t c = (Byte)temp[i];
+          if (c == 0)
+            break;
+          text[i] = c;
+        }
+        text[i] = 0;
+      }
+      else
+      {
+        if (dataSize > limit)
+          dataSize = limit;
+        WCHAR *dest = text;
+        const bool needUpper = (dataSize <= 8)
+            && (propID == kpidCRC || propID == kpidChecksum);
+        for (UInt32 i = 0; i < dataSize; i++)
+        {
+          unsigned b = ((const Byte *)data)[i];
+          if (needUpper)
+          {
+            dest[0] = (WCHAR)GetHex_Upper((b >> 4) & 0xF);
+            dest[1] = (WCHAR)GetHex_Upper(b & 0xF);
+          }
+          else
+          {
+            dest[0] = (WCHAR)GetHex_Lower((b >> 4) & 0xF);
+            dest[1] = (WCHAR)GetHex_Lower(b & 0xF);
+          }
+          dest += 2;
+        }
+        *dest = 0;
+      }
+    }
+    return 0;
+  }
+  /*
+  {
+    NCOM::CPropVariant prop;
+    if (propID == kpidType)
+      string = GetFileType(index);
+    else
+    {
+      HRESULT result = m_ArchiveFolder->GetProperty(index, propID, &prop);
+      if (result != S_OK)
+      {
+        // PrintMessage("GetPropertyValue error");
+        return 0;
+      }
+      string = ConvertPropertyToString(prop, propID, false);
+    }
+  }
+  */
+  // const NFind::CFileInfo &aFileInfo = m_Files[index];
+
+  NCOM::CPropVariant prop;
+  /*
+  bool needRead = true;
+  if (propID == kpidSize)
+  {
+    CComPtr<IFolderGetItemFullSize> getItemFullSize;
+    if (_folder.QueryInterface(&getItemFullSize) == S_OK)
+    {
+      if (getItemFullSize->GetItemFullSize(index, &prop) == S_OK)
+        needRead = false;
+    }
+  }
+  if (needRead)
+  */
+
+  if (item.cchTextMax < 32)
+    return 0;
+
+  if (propID == kpidName)
+  {
+    if (_folderGetItemName)
+    {
+      const wchar_t *name = NULL;
+      unsigned nameLen = 0;
+      _folderGetItemName->GetItemName(realIndex, &name, &nameLen);
+      
+      if (name)
+      {
+        unsigned dest = 0;
+        unsigned limit = item.cchTextMax - 1;
+        
+        for (unsigned i = 0; dest < limit;)
+        {
+          wchar_t c = name[i++];
+          if (c == 0)
+            break;
+          text[dest++] = c;
+          
+          if (c != ' ')
+          {
+            if (c != 0x202E) // RLO
+              continue;
+            text[(size_t)dest - 1] = '_';
+            continue;
+          }
+          
+          if (name[i] != ' ')
+            continue;
+          
+          unsigned t = 1;
+          for (; name[i + t] == ' '; t++);
+
+          if (t >= 4 && dest + 4 < limit)
+          {
+            text[dest++] = '.';
+            text[dest++] = '.';
+            text[dest++] = '.';
+            text[dest++] = ' ';
+            i += t;
+          }
+        }
+
+        if (dest == 0)
+          text[dest++]= '_';
+
+        #ifdef _WIN32
+        else if (text[(size_t)dest - 1] == ' ')
+        {
+          if (dest < limit)
+            text[dest++] = SPACE_TERMINATOR_CHAR;
+          else
+            text[dest - 1] = SPACE_REPLACE_CHAR;
+        }
+        #endif
+
+        text[dest] = 0;
+        // OutputDebugStringW(text);
+        return 0;
+      }
+    }
+  }
+  
+  if (propID == kpidPrefix)
+  {
+    if (_folderGetItemName)
+    {
+      const wchar_t *name = NULL;
+      unsigned nameLen = 0;
+      _folderGetItemName->GetItemPrefix(realIndex, &name, &nameLen);
+      if (name)
+      {
+        unsigned dest = 0;
+        unsigned limit = item.cchTextMax - 1;
+        for (unsigned i = 0; dest < limit;)
+        {
+          wchar_t c = name[i++];
+          if (c == 0)
+            break;
+          text[dest++] = c;
+        }
+        text[dest] = 0;
+        return 0;
+      }
+    }
+  }
+  
+  HRESULT res = _folder->GetProperty(realIndex, propID, &prop);
+  
+  if (res != S_OK)
+  {
+    MyStringCopy(text, L"Error: ");
+    // s = UString("Error: ") + HResultToMessage(res);
+  }
+  else if ((prop.vt == VT_UI8 || prop.vt == VT_UI4 || prop.vt == VT_UI2) && IsSizeProp(propID))
+  {
+    UInt64 v = 0;
+    ConvertPropVariantToUInt64(prop, v);
+    ConvertSizeToString(v, text);
+  }
+  else if (prop.vt == VT_BSTR)
+  {
+    unsigned limit = item.cchTextMax - 1;
+    const wchar_t *src = prop.bstrVal;
+    unsigned i;
+    for (i = 0; i < limit; i++)
+    {
+      wchar_t c = src[i];
+      if (c == 0) break;
+      if (c == 0xA) c = ' ';
+      if (c == 0xD) c = ' ';
+      text[i] = c;
+    }
+    text[i] = 0;
+  }
+  else
+  {
+    char temp[64];
+    ConvertPropertyToShortString2(temp, prop, propID, _timestampLevel);
+    unsigned i;
+    unsigned limit = item.cchTextMax - 1;
+    for (i = 0; i < limit; i++)
+    {
+      wchar_t c = (Byte)temp[i];
+      if (c == 0)
+        break;
+      text[i] = c;
+    }
+    text[i] = 0;
+  }
+  
+  return 0;
+}
+
+#ifndef UNDER_CE
+extern DWORD g_ComCtl32Version;
+#endif
+
+void CPanel::OnItemChanged(NMLISTVIEW *item)
+{
+  int index = (int)item->lParam;
+  if (index == kParentIndex)
+    return;
+  bool oldSelected = (item->uOldState & LVIS_SELECTED) != 0;
+  bool newSelected = (item->uNewState & LVIS_SELECTED) != 0;
+  // Don't change this code. It works only with such check
+  if (oldSelected != newSelected)
+    _selectedStatusVector[index] = newSelected;
+}
+
+extern bool g_LVN_ITEMACTIVATE_Support;
+
+void CPanel::OnNotifyActivateItems()
+{
+  bool alt = IsKeyDown(VK_MENU);
+  bool ctrl = IsKeyDown(VK_CONTROL);
+  bool shift = IsKeyDown(VK_SHIFT);
+  if (!shift && alt && !ctrl)
+    Properties();
+  else
+    OpenSelectedItems(!shift || alt || ctrl);
+}
+
+bool CPanel::OnNotifyList(LPNMHDR header, LRESULT &result)
+{
+  switch (header->code)
+  {
+    case LVN_ITEMCHANGED:
+    {
+      if (_enableItemChangeNotify)
+      {
+        if (!_mySelectMode)
+          OnItemChanged((LPNMLISTVIEW)header);
+        
+        // Post_Refresh_StatusBar();
+        /* 9.26: we don't call Post_Refresh_StatusBar.
+           it was very slow if we select big number of files
+           and then clead slection by selecting just new file.
+           probably it called slow Refresh_StatusBar for each item deselection.
+           I hope Refresh_StatusBar still will be called for each key / mouse action.
+        */
+      }
+      return false;
+    }
+    /*
+
+    case LVN_ODSTATECHANGED:
+      {
+      break;
+      }
+    */
+
+    case LVN_GETDISPINFOW:
+    {
+      LV_DISPINFOW *dispInfo = (LV_DISPINFOW *)header;
+
+      //is the sub-item information being requested?
+
+      if ((dispInfo->item.mask & LVIF_TEXT) != 0 ||
+          (dispInfo->item.mask & LVIF_IMAGE) != 0)
+        SetItemText(dispInfo->item);
+      {
+        // 20.03:
+        result = 0;
+        return true;
+        // old 7-Zip:
+        // return false;
+      }
+    }
+    case LVN_KEYDOWN:
+    {
+      LPNMLVKEYDOWN keyDownInfo = LPNMLVKEYDOWN(header);
+      bool boolResult = OnKeyDown(keyDownInfo, result);
+      switch (keyDownInfo->wVKey)
+      {
+        case VK_CONTROL:
+        case VK_SHIFT:
+        case VK_MENU:
+          break;
+        default:
+          Post_Refresh_StatusBar();
+      }
+      return boolResult;
+    }
+
+    case LVN_COLUMNCLICK:
+      OnColumnClick(LPNMLISTVIEW(header));
+      return false;
+
+    case LVN_ITEMACTIVATE:
+      if (g_LVN_ITEMACTIVATE_Support)
+      {
+        OnNotifyActivateItems();
+        return false;
+      }
+      break;
+    case NM_DBLCLK:
+    case NM_RETURN:
+      if (!g_LVN_ITEMACTIVATE_Support)
+      {
+        OnNotifyActivateItems();
+        return false;
+      }
+      break;
+
+    case NM_RCLICK:
+      Post_Refresh_StatusBar();
+      break;
+
+    /*
+      return OnRightClick((LPNMITEMACTIVATE)header, result);
+    */
+      /*
+      case NM_CLICK:
+      SendRefreshStatusBarMessage();
+      return 0;
+      
+        // TODO : Handler default action...
+        return 0;
+        case LVN_ITEMCHANGED:
+        {
+        NMLISTVIEW *pNMLV = (NMLISTVIEW *) lpnmh;
+        SelChange(pNMLV);
+        return TRUE;
+        }
+        case NM_SETFOCUS:
+        return onSetFocus(NULL);
+        case NM_KILLFOCUS:
+        return onKillFocus(NULL);
+      */
+    case NM_CLICK:
+    {
+      // we need SetFocusToList, if we drag-select items from other panel.
+      SetFocusToList();
+      Post_Refresh_StatusBar();
+      if (_mySelectMode)
+        #ifndef UNDER_CE
+        if (g_ComCtl32Version >= MAKELONG(71, 4))
+        #endif
+          OnLeftClick((MY_NMLISTVIEW_NMITEMACTIVATE *)header);
+      return false;
+    }
+    case LVN_BEGINLABELEDITW:
+      result = OnBeginLabelEdit((LV_DISPINFOW *)header);
+      return true;
+    case LVN_ENDLABELEDITW:
+      result = OnEndLabelEdit((LV_DISPINFOW *)header);
+      return true;
+
+    case NM_CUSTOMDRAW:
+    {
+      if (_mySelectMode || (_markDeletedItems && _thereAreDeletedItems))
+        return OnCustomDraw((LPNMLVCUSTOMDRAW)header, result);
+      break;
+    }
+    case LVN_BEGINDRAG:
+    {
+      OnDrag((LPNMLISTVIEW)header);
+      Post_Refresh_StatusBar();
+      break;
+    }
+    // case LVN_BEGINRDRAG:
+  }
+  return false;
+}
+
+bool CPanel::OnCustomDraw(LPNMLVCUSTOMDRAW lplvcd, LRESULT &result)
+{
+  switch (lplvcd->nmcd.dwDrawStage)
+  {
+  case CDDS_PREPAINT :
+    result = CDRF_NOTIFYITEMDRAW;
+    return true;
+    
+  case CDDS_ITEMPREPAINT:
+    /*
+    SelectObject(lplvcd->nmcd.hdc,
+    GetFontForItem(lplvcd->nmcd.dwItemSpec,
+    lplvcd->nmcd.lItemlParam) );
+    lplvcd->clrText = GetColorForItem(lplvcd->nmcd.dwItemSpec,
+    lplvcd->nmcd.lItemlParam);
+    lplvcd->clrTextBk = GetBkColorForItem(lplvcd->nmcd.dwItemSpec,
+    lplvcd->nmcd.lItemlParam);
+    */
+    int realIndex = (int)lplvcd->nmcd.lItemlParam;
+    lplvcd->clrTextBk = _listView.GetBkColor();
+    if (_mySelectMode)
+    {
+      if (realIndex != kParentIndex && _selectedStatusVector[realIndex])
+       lplvcd->clrTextBk = RGB(255, 192, 192);
+    }
+
+    if (_markDeletedItems && _thereAreDeletedItems)
+    {
+      if (IsItem_Deleted(realIndex))
+        lplvcd->clrText = RGB(255, 0, 0);
+    }
+    // lplvcd->clrText = RGB(0, 0, 0);
+    // result = CDRF_NEWFONT;
+    result = CDRF_NOTIFYITEMDRAW;
+    return true;
+    
+    // return false;
+    // return true;
+    /*
+    case CDDS_SUBITEM | CDDS_ITEMPREPAINT:
+    if (lplvcd->iSubItem == 0)
+    {
+    // lplvcd->clrText = RGB(255, 0, 0);
+    lplvcd->clrTextBk = RGB(192, 192, 192);
+    }
+    else
+    {
+    lplvcd->clrText = RGB(0, 0, 0);
+    lplvcd->clrTextBk = RGB(255, 255, 255);
+    }
+    return true;
+    */
+
+        /* At this point, you can change the background colors for the item
+        and any subitems and return CDRF_NEWFONT. If the list-view control
+        is in report mode, you can simply return CDRF_NOTIFYSUBITEMREDRAW
+        to customize the item's subitems individually */
+  }
+  return false;
+}
+
+void CPanel::Refresh_StatusBar()
+{
+  /*
+  g_name_cnt++;
+  char s[256];
+  sprintf(s, "g_name_cnt = %8d", g_name_cnt);
+  OutputDebugStringA(s);
+  */
+  // DWORD dw = GetTickCount();
+
+  CRecordVector<UInt32> indices;
+  GetOperatedItemIndices(indices);
+
+  wchar_t temp[32];
+  ConvertUInt32ToString(indices.Size(), temp);
+  wcscat(temp, L" / ");
+  ConvertUInt32ToString(_selectedStatusVector.Size(), temp + wcslen(temp));
+
+  // UString s1 = MyFormatNew(g_App.LangString_N_SELECTED_ITEMS, NumberToString(indices.Size()));
+  // UString s1 = MyFormatNew(IDS_N_SELECTED_ITEMS, NumberToString(indices.Size()));
+  _statusBar.SetText(0, MyFormatNew(g_App.LangString_N_SELECTED_ITEMS, temp));
+  // _statusBar.SetText(0, MyFormatNew(IDS_N_SELECTED_ITEMS, NumberToString(indices.Size())));
+
+  wchar_t selectSizeString[32];
+  selectSizeString[0] = 0;
+
+  if (indices.Size() > 0)
+  {
+    // for (unsigned ttt = 0; ttt < 1000; ttt++) {
+    UInt64 totalSize = 0;
+    FOR_VECTOR (i, indices)
+      totalSize += GetItemSize(indices[i]);
+    ConvertSizeToString(totalSize, selectSizeString);
+    // }
+  }
+  _statusBar.SetText(1, selectSizeString);
+
+  int focusedItem = _listView.GetFocusedItem();
+  wchar_t sizeString[32];
+  sizeString[0] = 0;
+  wchar_t dateString[32];
+  dateString[0] = 0;
+  if (focusedItem >= 0 && _listView.GetSelectedCount() > 0)
+  {
+    int realIndex = GetRealItemIndex(focusedItem);
+    if (realIndex != kParentIndex)
+    {
+      ConvertSizeToString(GetItemSize(realIndex), sizeString);
+      NCOM::CPropVariant prop;
+      if (_folder->GetProperty(realIndex, kpidMTime, &prop) == S_OK)
+      {
+        char dateString2[32];
+        dateString2[0] = 0;
+        ConvertPropertyToShortString2(dateString2, prop, kpidMTime);
+        for (unsigned i = 0;; i++)
+        {
+          char c = dateString2[i];
+          dateString[i] = (Byte)c;
+          if (c == 0)
+            break;
+        }
+      }
+    }
+  }
+  _statusBar.SetText(2, sizeString);
+  _statusBar.SetText(3, dateString);
+  
+  // _statusBar.SetText(4, nameString);
+  // _statusBar2.SetText(1, MyFormatNew(L"{0} bytes", NumberToStringW(totalSize)));
+  // }
+  /*
+  dw = GetTickCount() - dw;
+  sprintf(s, "status = %8d ms", dw);
+  OutputDebugStringA(s);
+  */
+}
diff --git a/CPP/7zip/UI/FileManager/PanelMenu.cpp b/CPP/7zip/UI/FileManager/PanelMenu.cpp
new file mode 100644
index 0000000..1a09a8f
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelMenu.cpp
@@ -0,0 +1,1153 @@
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/COM.h"
+#include "../../../Windows/Clipboard.h"
+#include "../../../Windows/Menu.h"
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#include "../../PropID.h"
+#include "../Common/PropIDUtils.h"
+#include "../Explorer/ContextMenu.h"
+
+#include "App.h"
+#include "FormatUtils.h"
+#include "LangUtils.h"
+#include "ListViewDialog.h"
+#include "MyLoadMenu.h"
+#include "PropertyName.h"
+
+#include "resource.h"
+#include "PropertyNameRes.h"
+
+using namespace NWindows;
+
+extern
+LONG g_DllRefCount;
+LONG g_DllRefCount = 0;
+
+static const UINT kSevenZipStartMenuID = kMenuCmdID_Plugin_Start;
+static const UINT kSystemStartMenuID = kMenuCmdID_Plugin_Start + 400;
+
+void CPanel::InvokeSystemCommand(const char *command)
+{
+  NCOM::CComInitializer comInitializer;
+  if (!IsFsOrPureDrivesFolder())
+    return;
+  CRecordVector<UInt32> operatedIndices;
+  GetOperatedItemIndices(operatedIndices);
+  if (operatedIndices.IsEmpty())
+    return;
+  CMyComPtr<IContextMenu> contextMenu;
+  if (CreateShellContextMenu(operatedIndices, contextMenu) != S_OK)
+    return;
+
+  CMINVOKECOMMANDINFO ci;
+  ZeroMemory(&ci, sizeof(ci));
+  ci.cbSize = sizeof(CMINVOKECOMMANDINFO);
+  ci.hwnd = GetParent();
+  ci.lpVerb = command;
+  contextMenu->InvokeCommand(&ci);
+}
+
+static const char * const kSeparator = "------------------------";
+static const char * const kSeparatorSmall = "----------------";
+
+extern UString ConvertSizeToString(UInt64 value) throw();
+bool IsSizeProp(UINT propID) throw();
+
+UString GetOpenArcErrorMessage(UInt32 errorFlags);
+
+
+static void AddListAscii(CListViewDialog &dialog, const char *s)
+{
+  dialog.Strings.Add((UString)s);
+  dialog.Values.AddNew();
+}
+
+static void AddSeparator(CListViewDialog &dialog)
+{
+  AddListAscii(dialog, kSeparator);
+}
+
+static void AddSeparatorSmall(CListViewDialog &dialog)
+{
+  AddListAscii(dialog, kSeparatorSmall);
+}
+
+static void AddPropertyPair(const UString &name, const UString &val, CListViewDialog &dialog)
+{
+  dialog.Strings.Add(name);
+  dialog.Values.Add(val);
+}
+
+
+static void AddPropertyString(PROPID propID, const wchar_t *nameBSTR,
+    const NCOM::CPropVariant &prop, CListViewDialog &dialog)
+{
+  if (prop.vt != VT_EMPTY)
+  {
+    UString val;
+
+    if (propID == kpidErrorFlags ||
+        propID == kpidWarningFlags)
+    {
+      UInt32 flags = GetOpenArcErrorFlags(prop);
+      if (flags == 0)
+        return;
+      if (flags != 0)
+        val = GetOpenArcErrorMessage(flags);
+    }
+
+    if (val.IsEmpty())
+    {
+      if ((prop.vt == VT_UI8 || prop.vt == VT_UI4 || prop.vt == VT_UI2) && IsSizeProp(propID))
+      {
+        UInt64 v = 0;
+        ConvertPropVariantToUInt64(prop, v);
+        val = ConvertSizeToString(v);
+      }
+      else
+        ConvertPropertyToString2(val, prop, propID);
+    }
+
+    if (!val.IsEmpty())
+    {
+      if (propID == kpidErrorType)
+      {
+        AddPropertyPair(L"Open WARNING:", L"Cannot open the file as expected archive type", dialog);
+      }
+      AddPropertyPair(GetNameOfProperty(propID, nameBSTR), val, dialog);
+    }
+  }
+}
+
+
+static void AddPropertyString(PROPID propID, UInt64 val, CListViewDialog &dialog)
+{
+  NCOM::CPropVariant prop = val;
+  AddPropertyString(propID, NULL, prop, dialog);
+}
+
+
+static inline unsigned GetHex_Upper(unsigned v)
+{
+  return (v < 10) ? ('0' + v) : ('A' + (v - 10));
+}
+
+static inline unsigned GetHex_Lower(unsigned v)
+{
+  return (v < 10) ? ('0' + v) : ('a' + (v - 10));
+}
+
+static const Byte kSpecProps[] =
+{
+  kpidPath,
+  kpidType,
+  kpidErrorType,
+  kpidError,
+  kpidErrorFlags,
+  kpidWarning,
+  kpidWarningFlags,
+  kpidOffset,
+  kpidPhySize,
+  kpidTailSize
+};
+
+void CPanel::Properties()
+{
+  CMyComPtr<IGetFolderArcProps> getFolderArcProps;
+  _folder.QueryInterface(IID_IGetFolderArcProps, &getFolderArcProps);
+  if (!getFolderArcProps)
+  {
+    InvokeSystemCommand("properties");
+    return;
+  }
+  
+  {
+    CListViewDialog message;
+    // message.DeleteIsAllowed = false;
+    // message.SelectFirst = false;
+
+    CRecordVector<UInt32> operatedIndices;
+    GetOperatedItemIndices(operatedIndices);
+    
+    if (operatedIndices.Size() == 1)
+    {
+      UInt32 index = operatedIndices[0];
+      // message += "Item:\n");
+      UInt32 numProps;
+      if (_folder->GetNumberOfProperties(&numProps) == S_OK)
+      {
+        for (UInt32 i = 0; i < numProps; i++)
+        {
+          CMyComBSTR name;
+          PROPID propID;
+          VARTYPE varType;
+          
+          if (_folder->GetPropertyInfo(i, &name, &propID, &varType) != S_OK)
+            continue;
+          
+          NCOM::CPropVariant prop;
+          if (_folder->GetProperty(index, propID, &prop) != S_OK)
+            continue;
+          AddPropertyString(propID, name, prop, message);
+        }
+      }
+
+
+      if (_folderRawProps)
+      {
+        _folderRawProps->GetNumRawProps(&numProps);
+        for (UInt32 i = 0; i < numProps; i++)
+        {
+          CMyComBSTR name;
+          PROPID propID;
+          if (_folderRawProps->GetRawPropInfo(i, &name, &propID) != S_OK)
+            continue;
+
+          const void *data;
+          UInt32 dataSize;
+          UInt32 propType;
+          if (_folderRawProps->GetRawProp(index, propID, &data, &dataSize, &propType) != S_OK)
+            continue;
+
+          if (dataSize != 0)
+          {
+            AString s;
+            if (propID == kpidNtSecure)
+              ConvertNtSecureToString((const Byte *)data, dataSize, s);
+            else
+            {
+              const UInt32 kMaxDataSize = 64;
+              if (dataSize > kMaxDataSize)
+              {
+                s += "data:";
+                s.Add_UInt32(dataSize);
+              }
+              else
+              {
+                const bool needUpper = (dataSize <= 8)
+                    && (propID == kpidCRC || propID == kpidChecksum);
+                for (UInt32 k = 0; k < dataSize; k++)
+                {
+                  const Byte b = ((const Byte *)data)[k];
+                  if (needUpper)
+                  {
+                    s += (char)GetHex_Upper((b >> 4) & 0xF);
+                    s += (char)GetHex_Upper(b & 0xF);
+                  }
+                  else
+                  {
+                    s += (char)GetHex_Lower((b >> 4) & 0xF);
+                    s += (char)GetHex_Lower(b & 0xF);
+                  }
+                }
+              }
+            }
+            AddPropertyPair(GetNameOfProperty(propID, name), (UString)s.Ptr(), message);
+          }
+        }
+      }
+
+      AddSeparator(message);
+    }
+    else if (operatedIndices.Size() >= 1)
+    {
+      UInt64 packSize = 0;
+      UInt64 unpackSize = 0;
+      UInt64 numFiles = 0;
+      UInt64 numDirs = 0;
+
+      FOR_VECTOR (i, operatedIndices)
+      {
+        const UInt32 index = operatedIndices[i];
+        unpackSize += GetItemSize(index);
+        packSize += GetItem_UInt64Prop(index, kpidPackSize);
+        if (IsItem_Folder(index))
+        {
+          numDirs++;
+          numDirs += GetItem_UInt64Prop(index, kpidNumSubDirs);
+          numFiles += GetItem_UInt64Prop(index, kpidNumSubFiles);
+        }
+        else
+          numFiles++;
+      }
+      {
+        wchar_t temp[32];
+        ConvertUInt32ToString(operatedIndices.Size(), temp);
+        AddPropertyPair(L"", MyFormatNew(g_App.LangString_N_SELECTED_ITEMS, temp), message);
+      }
+
+      if (numDirs != 0)
+        AddPropertyString(kpidNumSubDirs, numDirs, message);
+      if (numFiles != 0)
+        AddPropertyString(kpidNumSubFiles, numFiles, message);
+      AddPropertyString(kpidSize, unpackSize, message);
+      AddPropertyString(kpidPackSize, packSize, message);
+
+      AddSeparator(message);
+    }
+
+        
+    /*
+    AddLangString(message, IDS_PROP_FILE_TYPE);
+    message += kPropValueSeparator;
+    message += GetFolderTypeID();
+    message.Add_LF();
+    */
+
+    {
+      NCOM::CPropVariant prop;
+      if (_folder->GetFolderProperty(kpidPath, &prop) == S_OK)
+      {
+        AddPropertyString(kpidName, L"Path", prop, message);
+      }
+    }
+
+    CMyComPtr<IFolderProperties> folderProperties;
+    _folder.QueryInterface(IID_IFolderProperties, &folderProperties);
+    if (folderProperties)
+    {
+      UInt32 numProps;
+      if (folderProperties->GetNumberOfFolderProperties(&numProps) == S_OK)
+      {
+        for (UInt32 i = 0; i < numProps; i++)
+        {
+          CMyComBSTR name;
+          PROPID propID;
+          VARTYPE vt;
+          if (folderProperties->GetFolderPropertyInfo(i, &name, &propID, &vt) != S_OK)
+            continue;
+          NCOM::CPropVariant prop;
+          if (_folder->GetFolderProperty(propID, &prop) != S_OK)
+            continue;
+          AddPropertyString(propID, name, prop, message);
+        }
+      }
+    }
+
+    if (getFolderArcProps)
+    {
+      CMyComPtr<IFolderArcProps> getProps;
+      getFolderArcProps->GetFolderArcProps(&getProps);
+      if (getProps)
+      {
+        UInt32 numLevels;
+        if (getProps->GetArcNumLevels(&numLevels) != S_OK)
+          numLevels = 0;
+        for (UInt32 level2 = 0; level2 < numLevels; level2++)
+        {
+          {
+            UInt32 level = numLevels - 1 - level2;
+            UInt32 numProps;
+            if (getProps->GetArcNumProps(level, &numProps) == S_OK)
+            {
+              const int kNumSpecProps = ARRAY_SIZE(kSpecProps);
+
+              AddSeparator(message);
+              
+              for (Int32 i = -(int)kNumSpecProps; i < (Int32)numProps; i++)
+              {
+                CMyComBSTR name;
+                PROPID propID;
+                VARTYPE vt;
+                if (i < 0)
+                  propID = kSpecProps[i + kNumSpecProps];
+                else if (getProps->GetArcPropInfo(level, i, &name, &propID, &vt) != S_OK)
+                  continue;
+                NCOM::CPropVariant prop;
+                if (getProps->GetArcProp(level, propID, &prop) != S_OK)
+                  continue;
+                AddPropertyString(propID, name, prop, message);
+              }
+            }
+          }
+          
+          if (level2 < numLevels - 1)
+          {
+            UInt32 level = numLevels - 1 - level2;
+            UInt32 numProps;
+            if (getProps->GetArcNumProps2(level, &numProps) == S_OK)
+            {
+              AddSeparatorSmall(message);
+              for (Int32 i = 0; i < (Int32)numProps; i++)
+              {
+                CMyComBSTR name;
+                PROPID propID;
+                VARTYPE vt;
+                if (getProps->GetArcPropInfo2(level, i, &name, &propID, &vt) != S_OK)
+                  continue;
+                NCOM::CPropVariant prop;
+                if (getProps->GetArcProp2(level, propID, &prop) != S_OK)
+                  continue;
+                AddPropertyString(propID, name, prop, message);
+              }
+            }
+          }
+        }
+        
+        {
+          // we ERROR message for NonOpen level
+              bool needSep = true;
+              const int kNumSpecProps = ARRAY_SIZE(kSpecProps);
+              for (Int32 i = -(int)kNumSpecProps; i < 0; i++)
+              {
+                CMyComBSTR name;
+                PROPID propID = kSpecProps[i + kNumSpecProps];
+                NCOM::CPropVariant prop;
+                if (getProps->GetArcProp(numLevels, propID, &prop) != S_OK)
+                  continue;
+                if (needSep)
+                {
+                  AddSeparator(message);
+                  AddSeparator(message);
+                  needSep = false;
+                }
+                AddPropertyString(propID, name, prop, message);
+              }
+        }
+
+      }
+    }
+
+    message.Title = LangString(IDS_PROPERTIES);
+    message.NumColumns = 2;
+    message.Create(GetParent());
+  }
+}
+
+
+
+void CPanel::EditCut()
+{
+  // InvokeSystemCommand("cut");
+}
+
+void CPanel::EditCopy()
+{
+  /*
+  CMyComPtr<IGetFolderArcProps> getFolderArcProps;
+  _folder.QueryInterface(IID_IGetFolderArcProps, &getFolderArcProps);
+  if (!getFolderArcProps)
+  {
+    InvokeSystemCommand("copy");
+    return;
+  }
+  */
+  UString s;
+  CRecordVector<UInt32> indices;
+  GetSelectedItemsIndices(indices);
+  FOR_VECTOR (i, indices)
+  {
+    if (i != 0)
+      s += "\xD\n";
+    s += GetItemName(indices[i]);
+  }
+  ClipboardSetText(_mainWindow, s);
+}
+
+void CPanel::EditPaste()
+{
+  /*
+  UStringVector names;
+  ClipboardGetFileNames(names);
+  CopyFromNoAsk(names);
+  UString s;
+  for (int i = 0; i < names.Size(); i++)
+  {
+    s += L' ';
+    s += names[i];
+  }
+
+  MessageBoxW(0, s, L"", 0);
+  */
+
+  // InvokeSystemCommand("paste");
+}
+
+
+
+struct CFolderPidls
+{
+  LPITEMIDLIST parent;
+  CRecordVector<LPITEMIDLIST> items;
+
+  CFolderPidls(): parent(NULL) {}
+  ~CFolderPidls()
+  {
+    FOR_VECTOR (i, items)
+      CoTaskMemFree(items[i]);
+    CoTaskMemFree(parent);
+  }
+};
+
+
+HRESULT CPanel::CreateShellContextMenu(
+    const CRecordVector<UInt32> &operatedIndices,
+    CMyComPtr<IContextMenu> &systemContextMenu)
+{
+  systemContextMenu.Release();
+  const UString folderPath = GetFsPath();
+
+  CMyComPtr<IShellFolder> desktopFolder;
+  RINOK(::SHGetDesktopFolder(&desktopFolder));
+  if (!desktopFolder)
+  {
+    // ShowMessage("Failed to get Desktop folder");
+    return E_FAIL;
+  }
+  
+  CFolderPidls pidls;
+  DWORD eaten;
+
+  // if (folderPath.IsEmpty()), then ParseDisplayName returns pidls of "My Computer"
+  RINOK(desktopFolder->ParseDisplayName(
+      GetParent(), NULL, folderPath.Ptr_non_const(),
+      &eaten, &pidls.parent, NULL));
+
+  /*
+  STRRET pName;
+  res = desktopFolder->GetDisplayNameOf(pidls.parent,  SHGDN_NORMAL, &pName);
+  WCHAR dir[MAX_PATH];
+  if (!SHGetPathFromIDListW(pidls.parent, dir))
+    dir[0] = 0;
+  */
+
+  if (!pidls.parent)
+    return E_FAIL;
+
+  if (operatedIndices.IsEmpty())
+  {
+    // how to get IContextMenu, if there are no selected files?
+    return E_FAIL;
+
+    /*
+    xp64 :
+    1) we can't use GetUIObjectOf() with (numItems == 0), it throws exception
+    2) we can't use desktopFolder->GetUIObjectOf() with absolute pidls of folder
+        context menu items are different in that case:
+          "Open / Explorer" for folder
+          "Delete" for "My Computer" icon
+          "Preperties" for "System"
+    */
+    /*
+    parentFolder = desktopFolder;
+    pidls.items.AddInReserved(pidls.parent);
+    pidls.parent = NULL;
+    */
+
+    // CreateViewObject() doesn't show all context menu items
+    /*
+    HRESULT res = parentFolder->CreateViewObject(
+        GetParent(), IID_IContextMenu, (void**)&systemContextMenu);
+    */
+  }
+  
+  CMyComPtr<IShellFolder> parentFolder;
+  RINOK(desktopFolder->BindToObject(pidls.parent,
+      NULL, IID_IShellFolder, (void**)&parentFolder));
+  if (!parentFolder)
+  {
+    // ShowMessage("Invalid file name");
+    return E_FAIL;
+  }
+  
+  pidls.items.ClearAndReserve(operatedIndices.Size());
+  FOR_VECTOR (i, operatedIndices)
+  {
+    LPITEMIDLIST pidl;
+    const UString fileName = GetItemRelPath2(operatedIndices[i]);
+    RINOK(parentFolder->ParseDisplayName(GetParent(), 0,
+        fileName.Ptr_non_const(), &eaten, &pidl, 0));
+    pidls.items.AddInReserved(pidl);
+  }
+  
+  // Get IContextMenu for items
+
+  RINOK(parentFolder->GetUIObjectOf(GetParent(), pidls.items.Size(),
+      (LPCITEMIDLIST *)(void *)&pidls.items.Front(), IID_IContextMenu, 0, (void**)&systemContextMenu));
+  
+  if (!systemContextMenu)
+  {
+    // ShowMessage("Unable to get context menu interface");
+    return E_FAIL;
+  }
+  return S_OK;
+}
+
+// #define SHOW_DEBUG_FM_CTX_MENU
+
+#ifdef SHOW_DEBUG_FM_CTX_MENU
+
+#include <stdio.h>
+
+// #include Common/IntToString.h"
+
+static void PrintHex(UString &s, UInt32 v)
+{
+  char sz[32];
+  ConvertUInt32ToHex(v, sz);
+  s += sz;
+}
+
+static void PrintContextStr(UString &s, IContextMenu *ctxm, unsigned i, unsigned id, const char *name)
+{
+  s += " | ";
+  name = name;
+  // s += name;
+  // s += ": ";
+
+  UString s1;
+  {
+    char buf[256];
+    buf[0] = 0;
+    HRESULT res = ctxm->GetCommandString(i, id,
+        NULL, buf, ARRAY_SIZE(buf) - 1);
+    if (res != S_OK)
+    {
+      PrintHex(s1, res);
+      s1.Add_Space();
+    }
+    s1 += GetUnicodeString(buf);
+  }
+
+  UString s2;
+  {
+    wchar_t buf2[256];
+    buf2[0] = 0;
+    HRESULT res = ctxm->GetCommandString(i, id | GCS_UNICODE,
+        NULL, (char *)buf2, ARRAY_SIZE(buf2) - 1);
+    if (res != S_OK)
+    {
+      PrintHex(s2, res);
+      s2.Add_Space();
+    }
+    s2 += buf2;
+  }
+  
+  s += s1;
+  if (s2.Compare(s1) != 0)
+  {
+    s += " Unicode: ";
+    s += s2;
+  }
+}
+
+
+static void PrintAllContextItems(IContextMenu *ctxm, unsigned num)
+{
+  for (unsigned i = 0; i < num; i++)
+  {
+    UString s;
+    s.Add_UInt32(i);
+    s += ": ";
+
+    /*
+    UString valid;
+    {
+      char name[256];
+      HRESULT res = ctxm->GetCommandString(i, GCS_VALIDATEA,
+        NULL, name, ARRAY_SIZE(name) - 1);
+      
+      if (res == S_OK)
+      {
+        // valid = "valid";
+      }
+      else if (res == S_FALSE)
+        valid = "non-valid";
+      else
+        PrintHex(valid, res);
+    }
+    s += valid;
+    */
+
+    PrintContextStr(s, ctxm, i, GCS_VALIDATEA, "valid");
+    PrintContextStr(s, ctxm, i, GCS_VERBA, "v");
+    PrintContextStr(s, ctxm, i, GCS_HELPTEXTA, "h");
+    OutputDebugStringW(s);
+  }
+}
+#endif
+
+void CPanel::CreateSystemMenu(HMENU menuSpec,
+    const CRecordVector<UInt32> &operatedIndices,
+    CMyComPtr<IContextMenu> &systemContextMenu)
+{
+  systemContextMenu.Release();
+
+  CreateShellContextMenu(operatedIndices, systemContextMenu);
+
+  if (!systemContextMenu)
+    return;
+  
+  /*
+  // Set up a CMINVOKECOMMANDINFO structure.
+  CMINVOKECOMMANDINFO ci;
+  ZeroMemory(&ci, sizeof(ci));
+  ci.cbSize = sizeof(CMINVOKECOMMANDINFO);
+  ci.hwnd = GetParent();
+  */
+  
+  /*
+  if (Sender == GoBtn)
+  {
+    // Verbs that can be used are cut, paste,
+    // properties, delete, and so on.
+    String action;
+    if (CutRb->Checked)
+      action = "cut";
+    else if (CopyRb->Checked)
+      action = "copy";
+    else if (DeleteRb->Checked)
+      action = "delete";
+    else if (PropertiesRb->Checked)
+      action = "properties";
+    
+    ci.lpVerb = action.c_str();
+    result = cm->InvokeCommand(&ci);
+    if (result)
+      ShowMessage(
+      "Error copying file to clipboard.");
+    
+  }
+  else
+  */
+  {
+    // HMENU hMenu = CreatePopupMenu();
+    CMenu popupMenu;
+    CMenuDestroyer menuDestroyer(popupMenu);
+    if (!popupMenu.CreatePopup())
+      throw 210503;
+
+    HMENU hMenu = popupMenu;
+
+    DWORD Flags = CMF_EXPLORE;
+    // Optionally the shell will show the extended
+    // context menu on some operating systems when
+    // the shift key is held down at the time the
+    // context menu is invoked. The following is
+    // commented out but you can uncommnent this
+    // line to show the extended context menu.
+    // Flags |= 0x00000080;
+    HRESULT res = systemContextMenu->QueryContextMenu(hMenu, 0, kSystemStartMenuID, 0x7FFF, Flags);
+
+    if (SUCCEEDED(res))
+    {
+      #ifdef SHOW_DEBUG_FM_CTX_MENU
+      PrintAllContextItems(systemContextMenu, (unsigned)res);
+      #endif
+      
+      CMenu menu;
+      menu.Attach(menuSpec);
+      CMenuItem menuItem;
+      menuItem.fMask = MIIM_SUBMENU | MIIM_TYPE | MIIM_ID;
+      menuItem.fType = MFT_STRING;
+      menuItem.hSubMenu = popupMenu.Detach();
+      menuDestroyer.Disable();
+      LangString(IDS_SYSTEM, menuItem.StringValue);
+      menu.InsertItem(0, true, menuItem);
+    }
+    /*
+    if (Cmd < 100 && Cmd != 0)
+    {
+      ci.lpVerb = MAKEINTRESOURCE(Cmd - 1);
+      ci.lpParameters = "";
+      ci.lpDirectory = "";
+      ci.nShow = SW_SHOWNORMAL;
+      cm->InvokeCommand(&ci);
+    }
+    // If Cmd is > 100 then it's one of our
+    // inserted menu items.
+    else
+      // Find the menu item.
+      for (int i = 0; i < popupMenu1->Items->Count; i++)
+      {
+        TMenuItem* menu = popupMenu1->Items->Items[i];
+        // Call its OnClick handler.
+        if (menu->Command == Cmd - 100)
+          menu->OnClick(this);
+      }
+      // Release the memory allocated for the menu.
+      DestroyMenu(hMenu);
+    */
+  }
+}
+
+void CPanel::CreateFileMenu(HMENU menuSpec)
+{
+  CreateFileMenu(menuSpec, _sevenZipContextMenu, _systemContextMenu, true);
+}
+
+void CPanel::CreateSevenZipMenu(HMENU menuSpec,
+    const CRecordVector<UInt32> &operatedIndices,
+    CMyComPtr<IContextMenu> &sevenZipContextMenu)
+{
+  sevenZipContextMenu.Release();
+
+  CMenu menu;
+  menu.Attach(menuSpec);
+  // CMenuDestroyer menuDestroyer(menu);
+  // menu.CreatePopup();
+
+  CZipContextMenu *contextMenuSpec = new CZipContextMenu;
+  CMyComPtr<IContextMenu> contextMenu = contextMenuSpec;
+  // if (contextMenu.CoCreateInstance(CLSID_CZipContextMenu, IID_IContextMenu) == S_OK)
+  {
+    /*
+    CMyComPtr<IInitContextMenu> initContextMenu;
+    if (contextMenu.QueryInterface(IID_IInitContextMenu, &initContextMenu) != S_OK)
+      return;
+    */
+    UString currentFolderUnicode = GetFsPath();
+    UStringVector names;
+    unsigned i;
+    for (i = 0; i < operatedIndices.Size(); i++)
+      names.Add(currentFolderUnicode + GetItemRelPath2(operatedIndices[i]));
+    CRecordVector<const wchar_t *> namePointers;
+    for (i = 0; i < operatedIndices.Size(); i++)
+      namePointers.Add(names[i]);
+    
+    // NFile::NDirectory::MySetCurrentDirectory(currentFolderUnicode);
+    if (contextMenuSpec->InitContextMenu(currentFolderUnicode, &namePointers.Front(),
+        operatedIndices.Size()) == S_OK)
+    {
+      HRESULT res = contextMenu->QueryContextMenu(menu, 0, kSevenZipStartMenuID,
+          kSystemStartMenuID - 1, 0);
+      bool sevenZipMenuCreated = SUCCEEDED(res);
+      if (sevenZipMenuCreated)
+      {
+        // if (res != 0)
+        {
+          // some "non-good" implementation of QueryContextMenu() could add some items to menu, but it return 0.
+          // so we still allow these items
+          sevenZipContextMenu = contextMenu;
+          #ifdef SHOW_DEBUG_FM_CTX_MENU
+          PrintAllContextItems(contextMenu, (unsigned)res);
+          #endif
+        }
+      }
+      else
+      {
+        // MessageBox_Error_HRESULT_Caption(res, L"QueryContextMenu");
+      }
+
+      // int code = HRESULT_CODE(res);
+      // int nextItemID = code;
+    }
+  }
+}
+
+static bool IsReadOnlyFolder(IFolderFolder *folder)
+{
+  if (!folder)
+    return false;
+
+  bool res = false;
+  {
+    NCOM::CPropVariant prop;
+    if (folder->GetFolderProperty(kpidReadOnly, &prop) == S_OK)
+      if (prop.vt == VT_BOOL)
+        res = VARIANT_BOOLToBool(prop.boolVal);
+  }
+  return res;
+}
+
+bool CPanel::IsThereReadOnlyFolder() const
+{
+  if (!_folderOperations)
+    return true;
+  if (IsReadOnlyFolder(_folder))
+    return true;
+  FOR_VECTOR (i, _parentFolders)
+  {
+    if (IsReadOnlyFolder(_parentFolders[i].ParentFolder))
+      return true;
+  }
+  return false;
+}
+
+bool CPanel::CheckBeforeUpdate(UINT resourceID)
+{
+  if (!_folderOperations)
+  {
+    MessageBox_Error_UnsupportOperation();
+    // resourceID = resourceID;
+    // MessageBoxErrorForUpdate(E_NOINTERFACE, resourceID);
+    return false;
+  }
+
+  for (int i = (int)_parentFolders.Size(); i >= 0; i--)
+  {
+    IFolderFolder *folder;
+    if (i == (int)_parentFolders.Size())
+      folder = _folder;
+    else
+      folder = _parentFolders[i].ParentFolder;
+    
+    if (!IsReadOnlyFolder(folder))
+      continue;
+    
+    UString s;
+    AddLangString(s, resourceID);
+    s.Add_LF();
+    AddLangString(s, IDS_OPERATION_IS_NOT_SUPPORTED);
+    s.Add_LF();
+    if (i == 0)
+      s += GetFolderPath(folder);
+    else
+      s += _parentFolders[i - 1].VirtualPath;
+    s.Add_LF();
+    AddLangString(s, IDS_PROP_READ_ONLY);
+    MessageBox_Error(s);
+    return false;
+  }
+
+  return true;
+}
+
+void CPanel::CreateFileMenu(HMENU menuSpec,
+    CMyComPtr<IContextMenu> &sevenZipContextMenu,
+    CMyComPtr<IContextMenu> &systemContextMenu,
+    bool programMenu)
+{
+  sevenZipContextMenu.Release();
+  systemContextMenu.Release();
+
+  CRecordVector<UInt32> operatedIndices;
+  GetOperatedItemIndices(operatedIndices);
+
+  CMenu menu;
+  menu.Attach(menuSpec);
+
+  if (!IsArcFolder())
+  {
+    CreateSevenZipMenu(menu, operatedIndices, sevenZipContextMenu);
+    // CreateSystemMenu is very slow if you call it inside ZIP archive with big number of files
+    // Windows probably can parse items inside ZIP archive.
+    if (g_App.ShowSystemMenu)
+      CreateSystemMenu(menu, operatedIndices, systemContextMenu);
+  }
+
+  /*
+  if (menu.GetItemCount() > 0)
+    menu.AppendItem(MF_SEPARATOR, 0, (LPCTSTR)0);
+  */
+
+  unsigned i;
+  for (i = 0; i < operatedIndices.Size(); i++)
+    if (IsItem_Folder(operatedIndices[i]))
+      break;
+  bool allAreFiles = (i == operatedIndices.Size());
+
+  CFileMenu fm;
+  
+  fm.readOnly = IsThereReadOnlyFolder();
+  fm.isHashFolder = IsHashFolder();
+  fm.isFsFolder = Is_IO_FS_Folder();
+  fm.programMenu = programMenu;
+  fm.allAreFiles = allAreFiles;
+  fm.numItems = operatedIndices.Size();
+
+  fm.isAltStreamsSupported = false;
+  
+  if (fm.numItems == 1)
+    fm.FilePath = us2fs(GetItemFullPath(operatedIndices[0]));
+
+  if (_folderAltStreams)
+  {
+    if (operatedIndices.Size() <= 1)
+    {
+      Int32 realIndex = -1;
+      if (operatedIndices.Size() == 1)
+        realIndex = operatedIndices[0];
+      Int32 val = 0;
+      if (_folderAltStreams->AreAltStreamsSupported(realIndex, &val) == S_OK)
+        fm.isAltStreamsSupported = IntToBool(val);
+    }
+  }
+  else
+  {
+    if (fm.numItems == 0)
+      fm.isAltStreamsSupported = IsFSFolder();
+    else
+      fm.isAltStreamsSupported = IsFolder_with_FsItems();
+  }
+
+  fm.Load(menu, menu.GetItemCount());
+}
+
+bool CPanel::InvokePluginCommand(unsigned id)
+{
+  return InvokePluginCommand(id, _sevenZipContextMenu, _systemContextMenu);
+}
+
+#if defined(_MSC_VER) && !defined(UNDER_CE)
+#define use_CMINVOKECOMMANDINFOEX
+#endif
+
+bool CPanel::InvokePluginCommand(unsigned id,
+    IContextMenu *sevenZipContextMenu, IContextMenu *systemContextMenu)
+{
+  UInt32 offset;
+  const bool isSystemMenu = (id >= kSystemStartMenuID);
+  if (isSystemMenu)
+  {
+    if (!systemContextMenu)
+      return false;
+    offset = id - kSystemStartMenuID;
+  }
+  else
+  {
+    if (!sevenZipContextMenu)
+      return false;
+    offset = id - kSevenZipStartMenuID;
+  }
+
+  #ifdef use_CMINVOKECOMMANDINFOEX
+    CMINVOKECOMMANDINFOEX
+  #else
+    CMINVOKECOMMANDINFO
+  #endif
+      commandInfo;
+  
+  memset(&commandInfo, 0, sizeof(commandInfo));
+  commandInfo.cbSize = sizeof(commandInfo);
+  
+  commandInfo.fMask = 0
+  #ifdef use_CMINVOKECOMMANDINFOEX
+    | CMIC_MASK_UNICODE
+  #endif
+    ;
+
+  commandInfo.hwnd = GetParent();
+  commandInfo.lpVerb = (LPCSTR)(MAKEINTRESOURCE(offset));
+  commandInfo.lpParameters = NULL;
+  // 19.01: fixed CSysString to AString
+  // MSDN suggest to send NULL: lpDirectory: This member is always NULL for menu items inserted by a Shell extension.
+  const AString currentFolderA (GetAnsiString(_currentFolderPrefix));
+  commandInfo.lpDirectory = (LPCSTR)(currentFolderA);
+  commandInfo.nShow = SW_SHOW;
+  
+  #ifdef use_CMINVOKECOMMANDINFOEX
+  
+  commandInfo.lpParametersW = NULL;
+  commandInfo.lpTitle = "";
+
+  /*
+  system ContextMenu handler supports ContextMenu subhandlers.
+  so InvokeCommand() converts (command_offset) from global number to subhandler number.
+  XP-64 / win10:
+      system ContextMenu converts (command_offset) in lpVerb only,
+      and it keeps lpVerbW unchanged.
+      also explorer.exe sends 0 in lpVerbW.
+  We try to keep compatibility with Windows Explorer here.
+  */
+  commandInfo.lpVerbW = NULL;
+
+  const UString currentFolderUnicode = _currentFolderPrefix;
+  commandInfo.lpDirectoryW = currentFolderUnicode;
+  commandInfo.lpTitleW = L"";
+  // commandInfo.ptInvoke.x = xPos;
+  // commandInfo.ptInvoke.y = yPos;
+  commandInfo.ptInvoke.x = 0;
+  commandInfo.ptInvoke.y = 0;
+  
+  #endif
+  
+  HRESULT result;
+  if (isSystemMenu)
+    result = systemContextMenu->InvokeCommand(LPCMINVOKECOMMANDINFO(&commandInfo));
+  else
+    result = sevenZipContextMenu->InvokeCommand(LPCMINVOKECOMMANDINFO(&commandInfo));
+  if (result == NOERROR)
+  {
+    KillSelection();
+    return true;
+  }
+  else
+    MessageBox_Error_HRESULT_Caption(result, L"InvokeCommand");
+  return false;
+}
+
+bool CPanel::OnContextMenu(HANDLE windowHandle, int xPos, int yPos)
+{
+  if (::GetParent((HWND)windowHandle) == _listView)
+  {
+    ShowColumnsContextMenu(xPos, yPos);
+    return true;
+  }
+
+  if (windowHandle != _listView)
+    return false;
+  /*
+  POINT point;
+  point.x = xPos;
+  point.y = yPos;
+  if (!_listView.ScreenToClient(&point))
+    return false;
+
+  LVHITTESTINFO info;
+  info.pt = point;
+  int index = _listView.HitTest(&info);
+  */
+
+  CRecordVector<UInt32> operatedIndices;
+  GetOperatedItemIndices(operatedIndices);
+
+  // negative x,y are possible for multi-screen modes.
+  // x=-1 && y=-1 for keyboard call (SHIFT+F10 and others).
+  if (xPos == -1 && yPos == -1)
+  {
+    if (operatedIndices.Size() == 0)
+    {
+      xPos = 0;
+      yPos = 0;
+    }
+    else
+    {
+      int itemIndex = _listView.GetNextItem(-1, LVNI_FOCUSED);
+      if (itemIndex == -1)
+        return false;
+      RECT rect;
+      if (!_listView.GetItemRect(itemIndex, &rect, LVIR_ICON))
+        return false;
+      xPos = (rect.left + rect.right) / 2;
+      yPos = (rect.top + rect.bottom) / 2;
+    }
+    POINT point = {xPos, yPos};
+    _listView.ClientToScreen(&point);
+    xPos = point.x;
+    yPos = point.y;
+  }
+
+  CMenu menu;
+  CMenuDestroyer menuDestroyer(menu);
+  menu.CreatePopup();
+
+  CMyComPtr<IContextMenu> sevenZipContextMenu;
+  CMyComPtr<IContextMenu> systemContextMenu;
+  CreateFileMenu(menu, sevenZipContextMenu, systemContextMenu, false);
+
+  unsigned id = menu.Track(TPM_LEFTALIGN
+      #ifndef UNDER_CE
+      | TPM_RIGHTBUTTON
+      #endif
+      | TPM_RETURNCMD | TPM_NONOTIFY,
+    xPos, yPos, _listView);
+
+  if (id == 0)
+    return true;
+
+  if (id >= kMenuCmdID_Plugin_Start)
+  {
+    InvokePluginCommand(id, sevenZipContextMenu, systemContextMenu);
+    return true;
+  }
+  if (ExecuteFileCommand(id))
+    return true;
+  return true;
+}
diff --git a/CPP/7zip/UI/FileManager/PanelOperations.cpp b/CPP/7zip/UI/FileManager/PanelOperations.cpp
new file mode 100644
index 0000000..e34e74f
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelOperations.cpp
@@ -0,0 +1,526 @@
+// PanelOperations.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/DynamicBuffer.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/COM.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "ComboDialog.h"
+
+#include "FSFolder.h"
+#include "FormatUtils.h"
+#include "LangUtils.h"
+#include "Panel.h"
+#include "UpdateCallback100.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NName;
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+enum EFolderOpType
+{
+  FOLDER_TYPE_CREATE_FOLDER = 0,
+  FOLDER_TYPE_DELETE = 1,
+  FOLDER_TYPE_RENAME = 2
+};
+
+class CThreadFolderOperations: public CProgressThreadVirt
+{
+  HRESULT ProcessVirt();
+public:
+  EFolderOpType OpType;
+  UString Name;
+  UInt32 Index;
+  CRecordVector<UInt32> Indices;
+
+  CMyComPtr<IFolderOperations> FolderOperations;
+  CMyComPtr<IProgress> UpdateCallback;
+  CUpdateCallback100Imp *UpdateCallbackSpec;
+  
+  CThreadFolderOperations(EFolderOpType opType): OpType(opType) {}
+  HRESULT DoOperation(CPanel &panel, const UString &progressTitle, const UString &titleError);
+};
+  
+HRESULT CThreadFolderOperations::ProcessVirt()
+{
+  NCOM::CComInitializer comInitializer;
+  switch (OpType)
+  {
+    case FOLDER_TYPE_CREATE_FOLDER:
+      return FolderOperations->CreateFolder(Name, UpdateCallback);
+    case FOLDER_TYPE_DELETE:
+      return FolderOperations->Delete(&Indices.Front(), Indices.Size(), UpdateCallback);
+    case FOLDER_TYPE_RENAME:
+      return FolderOperations->Rename(Index, Name, UpdateCallback);
+    default:
+      return E_FAIL;
+  }
+}
+
+
+HRESULT CThreadFolderOperations::DoOperation(CPanel &panel, const UString &progressTitle, const UString &titleError)
+{
+  UpdateCallbackSpec = new CUpdateCallback100Imp;
+  UpdateCallback = UpdateCallbackSpec;
+  UpdateCallbackSpec->ProgressDialog = this;
+
+  WaitMode = true;
+  Sync.FinalMessage.ErrorMessage.Title = titleError;
+
+  UpdateCallbackSpec->Init();
+
+  if (panel._parentFolders.Size() > 0)
+  {
+    const CFolderLink &fl = panel._parentFolders.Back();
+    UpdateCallbackSpec->PasswordIsDefined = fl.UsePassword;
+    UpdateCallbackSpec->Password = fl.Password;
+  }
+
+  MainWindow = panel._mainWindow; // panel.GetParent()
+  MainTitle = "7-Zip"; // LangString(IDS_APP_TITLE);
+  MainAddTitle = progressTitle + L' ';
+
+  RINOK(Create(progressTitle, MainWindow));
+  return Result;
+}
+
+#ifndef _UNICODE
+typedef int (WINAPI * SHFileOperationWP)(LPSHFILEOPSTRUCTW lpFileOp);
+#endif
+
+/*
+void CPanel::MessageBoxErrorForUpdate(HRESULT errorCode, UINT resourceID)
+{
+  if (errorCode == E_NOINTERFACE)
+    MessageBox_Error_UnsupportOperation();
+  else
+    MessageBox_Error_HRESULT_Caption(errorCode, LangString(resourceID));
+}
+*/
+
+void CPanel::DeleteItems(bool NON_CE_VAR(toRecycleBin))
+{
+  CDisableTimerProcessing disableTimerProcessing(*this);
+  CRecordVector<UInt32> indices;
+  GetOperatedItemIndices(indices);
+  if (indices.IsEmpty())
+    return;
+  CSelectedState state;
+  SaveSelectedState(state);
+
+  #ifndef UNDER_CE
+  // WM6 / SHFileOperationW doesn't ask user! So we use internal delete
+  if (IsFSFolder() && toRecycleBin)
+  {
+    bool useInternalDelete = false;
+    #ifndef _UNICODE
+    if (!g_IsNT)
+    {
+      CDynamicBuffer<CHAR> buffer;
+      FOR_VECTOR (i, indices)
+      {
+        const AString path (GetSystemString(GetItemFullPath(indices[i])));
+        buffer.AddData(path, path.Len() + 1);
+      }
+      *buffer.GetCurPtrAndGrow(1) = 0;
+      SHFILEOPSTRUCTA fo;
+      fo.hwnd = GetParent();
+      fo.wFunc = FO_DELETE;
+      fo.pFrom = (const CHAR *)buffer;
+      fo.pTo = 0;
+      fo.fFlags = 0;
+      if (toRecycleBin)
+        fo.fFlags |= FOF_ALLOWUNDO;
+      // fo.fFlags |= FOF_NOCONFIRMATION;
+      // fo.fFlags |= FOF_NOERRORUI;
+      // fo.fFlags |= FOF_SILENT;
+      // fo.fFlags |= FOF_WANTNUKEWARNING;
+      fo.fAnyOperationsAborted = FALSE;
+      fo.hNameMappings = 0;
+      fo.lpszProgressTitle = 0;
+      /* int res = */ ::SHFileOperationA(&fo);
+    }
+    else
+    #endif
+    {
+      CDynamicBuffer<WCHAR> buffer;
+      unsigned maxLen = 0;
+      const UString prefix = GetFsPath();
+      FOR_VECTOR (i, indices)
+      {
+        // L"\\\\?\\") doesn't work here.
+        const UString path = prefix + GetItemRelPath2(indices[i]);
+        if (path.Len() > maxLen)
+          maxLen = path.Len();
+        buffer.AddData(path, path.Len() + 1);
+      }
+      *buffer.GetCurPtrAndGrow(1) = 0;
+      if (maxLen >= MAX_PATH)
+      {
+        if (toRecycleBin)
+        {
+          MessageBox_Error_LangID(IDS_ERROR_LONG_PATH_TO_RECYCLE);
+          return;
+        }
+        useInternalDelete = true;
+      }
+      else
+      {
+        SHFILEOPSTRUCTW fo;
+        fo.hwnd = GetParent();
+        fo.wFunc = FO_DELETE;
+        fo.pFrom = (const WCHAR *)buffer;
+        fo.pTo = 0;
+        fo.fFlags = 0;
+        if (toRecycleBin)
+          fo.fFlags |= FOF_ALLOWUNDO;
+        fo.fAnyOperationsAborted = FALSE;
+        fo.hNameMappings = 0;
+        fo.lpszProgressTitle = 0;
+        // int res;
+        #ifdef _UNICODE
+        /* res = */ ::SHFileOperationW(&fo);
+        #else
+        SHFileOperationWP shFileOperationW = (SHFileOperationWP)
+          ::GetProcAddress(::GetModuleHandleW(L"shell32.dll"), "SHFileOperationW");
+        if (shFileOperationW == 0)
+          return;
+        /* res = */ shFileOperationW(&fo);
+        #endif
+      }
+    }
+    /*
+    if (fo.fAnyOperationsAborted)
+      MessageBox_Error_HRESULT_Caption(result, LangString(IDS_ERROR_DELETING));
+    */
+    if (!useInternalDelete)
+    {
+      RefreshListCtrl(state);
+      return;
+    }
+  }
+  #endif
+ 
+  // DeleteItemsInternal
+
+  if (!CheckBeforeUpdate(IDS_ERROR_DELETING))
+    return;
+
+  UInt32 titleID, messageID;
+  UString messageParam;
+  if (indices.Size() == 1)
+  {
+    int index = indices[0];
+    messageParam = GetItemRelPath2(index);
+    if (IsItem_Folder(index))
+    {
+      titleID = IDS_CONFIRM_FOLDER_DELETE;
+      messageID = IDS_WANT_TO_DELETE_FOLDER;
+    }
+    else
+    {
+      titleID = IDS_CONFIRM_FILE_DELETE;
+      messageID = IDS_WANT_TO_DELETE_FILE;
+    }
+  }
+  else
+  {
+    titleID = IDS_CONFIRM_ITEMS_DELETE;
+    messageID = IDS_WANT_TO_DELETE_ITEMS;
+    messageParam = NumberToString(indices.Size());
+  }
+  if (::MessageBoxW(GetParent(), MyFormatNew(messageID, messageParam), LangString(titleID), MB_OKCANCEL | MB_ICONQUESTION) != IDOK)
+    return;
+
+  CDisableNotify disableNotify(*this);
+  {
+    CThreadFolderOperations op(FOLDER_TYPE_DELETE);
+    op.FolderOperations = _folderOperations;
+    op.Indices = indices;
+    op.DoOperation(*this,
+        LangString(IDS_DELETING),
+        LangString(IDS_ERROR_DELETING));
+  }
+  RefreshTitleAlways();
+  RefreshListCtrl(state);
+}
+
+BOOL CPanel::OnBeginLabelEdit(LV_DISPINFOW * lpnmh)
+{
+  int realIndex = GetRealIndex(lpnmh->item);
+  if (realIndex == kParentIndex)
+    return TRUE;
+  if (IsThereReadOnlyFolder())
+    return TRUE;
+  return FALSE;
+}
+
+static bool IsCorrectFsName(const UString &name)
+{
+  const UString lastPart = name.Ptr((unsigned)(name.ReverseFind_PathSepar() + 1));
+  return
+      lastPart != L"." &&
+      lastPart != L"..";
+}
+
+bool CorrectFsPath(const UString &relBase, const UString &path, UString &result);
+
+bool CPanel::CorrectFsPath(const UString &path2, UString &result)
+{
+  return ::CorrectFsPath(GetFsPath(), path2, result);
+}
+
+BOOL CPanel::OnEndLabelEdit(LV_DISPINFOW * lpnmh)
+{
+  if (lpnmh->item.pszText == NULL)
+    return FALSE;
+  CDisableTimerProcessing disableTimerProcessing2(*this);
+
+  if (!CheckBeforeUpdate(IDS_ERROR_RENAMING))
+    return FALSE;
+
+  UString newName = lpnmh->item.pszText;
+  if (!IsCorrectFsName(newName))
+  {
+    MessageBox_Error_HRESULT(E_INVALIDARG);
+    return FALSE;
+  }
+
+  if (IsFSFolder())
+  {
+    UString correctName;
+    if (!CorrectFsPath(newName, correctName))
+    {
+      MessageBox_Error_HRESULT(E_INVALIDARG);
+      return FALSE;
+    }
+    newName = correctName;
+  }
+
+  SaveSelectedState(_selectedState);
+
+  int realIndex = GetRealIndex(lpnmh->item);
+  if (realIndex == kParentIndex)
+    return FALSE;
+  const UString prefix = GetItemPrefix(realIndex);
+
+
+  CDisableNotify disableNotify(*this);
+  {
+    CThreadFolderOperations op(FOLDER_TYPE_RENAME);
+    op.FolderOperations = _folderOperations;
+    op.Index = realIndex;
+    op.Name = newName;
+    /* HRESULTres = */ op.DoOperation(*this,
+        LangString(IDS_RENAMING),
+        LangString(IDS_ERROR_RENAMING));
+    // fixed in 9.26: we refresh list even after errors
+    // (it's more safe, since error can be at different stages, so list can be incorrect).
+    /*
+    if (res != S_OK)
+      return FALSE;
+    */
+  }
+
+  // Can't use RefreshListCtrl here.
+  // RefreshListCtrlSaveFocused();
+  _selectedState.FocusedName = prefix + newName;
+  _selectedState.FocusedName_Defined = true;
+  _selectedState.SelectFocused = true;
+
+  // We need clear all items to disable GetText before Reload:
+  // number of items can change.
+  // DeleteListItems();
+  // But seems it can still call GetText (maybe for current item)
+  // so we can't delete items.
+
+  _dontShowMode = true;
+
+  PostMsg(kReLoadMessage);
+  return TRUE;
+}
+
+bool Dlg_CreateFolder(HWND wnd, UString &destName);
+
+void CPanel::CreateFolder()
+{
+  if (IsHashFolder())
+    return;
+
+  if (!CheckBeforeUpdate(IDS_CREATE_FOLDER_ERROR))
+    return;
+
+  CDisableTimerProcessing disableTimerProcessing2(*this);
+  CSelectedState state;
+  SaveSelectedState(state);
+
+  UString newName;
+  if (!Dlg_CreateFolder(GetParent(), newName))
+    return;
+  
+  if (!IsCorrectFsName(newName))
+  {
+    MessageBox_Error_HRESULT(E_INVALIDARG);
+    return;
+  }
+
+  if (IsFSFolder())
+  {
+    UString correctName;
+    if (!CorrectFsPath(newName, correctName))
+    {
+      MessageBox_Error_HRESULT(E_INVALIDARG);
+      return;
+    }
+    newName = correctName;
+  }
+  
+  HRESULT res;
+  CDisableNotify disableNotify(*this);
+  {
+    CThreadFolderOperations op(FOLDER_TYPE_CREATE_FOLDER);
+    op.FolderOperations = _folderOperations;
+    op.Name = newName;
+    res = op.DoOperation(*this,
+        LangString(IDS_CREATE_FOLDER),
+        LangString(IDS_CREATE_FOLDER_ERROR));
+    /*
+    // fixed for 9.26: we must refresh always
+    if (res != S_OK)
+      return;
+    */
+  }
+  if (res == S_OK)
+  {
+    int pos = newName.Find(WCHAR_PATH_SEPARATOR);
+    if (pos >= 0)
+      newName.DeleteFrom((unsigned)(pos));
+    if (!_mySelectMode)
+      state.SelectedNames.Clear();
+    state.FocusedName = newName;
+    state.FocusedName_Defined = true;
+    state.SelectFocused = true;
+  }
+  RefreshTitleAlways();
+  RefreshListCtrl(state);
+}
+
+void CPanel::CreateFile()
+{
+  if (IsHashFolder())
+    return;
+
+  if (!CheckBeforeUpdate(IDS_CREATE_FILE_ERROR))
+    return;
+
+  CDisableTimerProcessing disableTimerProcessing2(*this);
+  CSelectedState state;
+  SaveSelectedState(state);
+  CComboDialog dlg;
+  LangString(IDS_CREATE_FILE, dlg.Title);
+  LangString(IDS_CREATE_FILE_NAME, dlg.Static);
+  LangString(IDS_CREATE_FILE_DEFAULT_NAME, dlg.Value);
+
+  if (dlg.Create(GetParent()) != IDOK)
+    return;
+
+  CDisableNotify disableNotify(*this);
+  
+  UString newName = dlg.Value;
+
+  if (IsFSFolder())
+  {
+    UString correctName;
+    if (!CorrectFsPath(newName, correctName))
+    {
+      MessageBox_Error_HRESULT(E_INVALIDARG);
+      return;
+    }
+    newName = correctName;
+  }
+
+  HRESULT result = _folderOperations->CreateFile(newName, 0);
+  if (result != S_OK)
+  {
+    MessageBox_Error_HRESULT_Caption(result, LangString(IDS_CREATE_FILE_ERROR));
+    // MessageBoxErrorForUpdate(result, IDS_CREATE_FILE_ERROR);
+    return;
+  }
+  int pos = newName.Find(WCHAR_PATH_SEPARATOR);
+  if (pos >= 0)
+    newName.DeleteFrom((unsigned)pos);
+  if (!_mySelectMode)
+    state.SelectedNames.Clear();
+  state.FocusedName = newName;
+  state.FocusedName_Defined = true;
+  state.SelectFocused = true;
+  RefreshListCtrl(state);
+}
+
+void CPanel::RenameFile()
+{
+  if (!CheckBeforeUpdate(IDS_ERROR_RENAMING))
+    return;
+  int index = _listView.GetFocusedItem();
+  if (index >= 0)
+    _listView.EditLabel(index);
+}
+
+void CPanel::ChangeComment()
+{
+  if (IsHashFolder())
+    return;
+  if (!CheckBeforeUpdate(IDS_COMMENT))
+    return;
+  CDisableTimerProcessing disableTimerProcessing2(*this);
+  int index = _listView.GetFocusedItem();
+  if (index < 0)
+    return;
+  int realIndex = GetRealItemIndex(index);
+  if (realIndex == kParentIndex)
+    return;
+  CSelectedState state;
+  SaveSelectedState(state);
+  UString comment;
+  {
+    NCOM::CPropVariant propVariant;
+    if (_folder->GetProperty(realIndex, kpidComment, &propVariant) != S_OK)
+      return;
+    if (propVariant.vt == VT_BSTR)
+      comment = propVariant.bstrVal;
+    else if (propVariant.vt != VT_EMPTY)
+      return;
+  }
+  UString name = GetItemRelPath2(realIndex);
+  CComboDialog dlg;
+  dlg.Title = name;
+  dlg.Title += " : ";
+  AddLangString(dlg.Title, IDS_COMMENT);
+  dlg.Value = comment;
+  LangString(IDS_COMMENT2, dlg.Static);
+  if (dlg.Create(GetParent()) != IDOK)
+    return;
+  NCOM::CPropVariant propVariant (dlg.Value);
+
+  CDisableNotify disableNotify(*this);
+  HRESULT result = _folderOperations->SetProperty(realIndex, kpidComment, &propVariant, NULL);
+  if (result != S_OK)
+  {
+    if (result == E_NOINTERFACE)
+      MessageBox_Error_UnsupportOperation();
+    else
+      MessageBox_Error_HRESULT_Caption(result, L"Set Comment Error");
+  }
+  RefreshListCtrl(state);
+}
diff --git a/CPP/7zip/UI/FileManager/PanelSelect.cpp b/CPP/7zip/UI/FileManager/PanelSelect.cpp
new file mode 100644
index 0000000..eab9e1a
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelSelect.cpp
@@ -0,0 +1,315 @@
+// PanelSelect.cpp
+
+#include "StdAfx.h"
+
+#include "resource.h"
+
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "ComboDialog.h"
+#include "LangUtils.h"
+#include "Panel.h"
+
+void CPanel::OnShiftSelectMessage()
+{
+  if (!_mySelectMode)
+    return;
+  int focusedItem = _listView.GetFocusedItem();
+  if (focusedItem < 0)
+    return;
+  if (!_selectionIsDefined)
+    return;
+  int startItem = MyMin(focusedItem, _prevFocusedItem);
+  int finishItem = MyMax(focusedItem, _prevFocusedItem);
+    
+  int numItems = _listView.GetItemCount();
+  for (int i = 0; i < numItems; i++)
+  {
+    int realIndex = GetRealItemIndex(i);
+    if (realIndex == kParentIndex)
+      continue;
+    if (i >= startItem && i <= finishItem)
+      if (_selectedStatusVector[realIndex] != _selectMark)
+      {
+        _selectedStatusVector[realIndex] = _selectMark;
+        _listView.RedrawItem(i);
+      }
+  }
+
+  _prevFocusedItem = focusedItem;
+}
+
+void CPanel::OnArrowWithShift()
+{
+  if (!_mySelectMode)
+    return;
+  int focusedItem = _listView.GetFocusedItem();
+  if (focusedItem < 0)
+    return;
+  int realIndex = GetRealItemIndex(focusedItem);
+  
+  if (_selectionIsDefined)
+  {
+    if (realIndex != kParentIndex)
+      _selectedStatusVector[realIndex] = _selectMark;
+  }
+  else
+  {
+    if (realIndex == kParentIndex)
+    {
+      _selectionIsDefined = true;
+      _selectMark = true;
+    }
+    else
+    {
+      _selectionIsDefined = true;
+      _selectMark = !_selectedStatusVector[realIndex];
+      _selectedStatusVector[realIndex] = _selectMark;
+    }
+  }
+  
+  _prevFocusedItem = focusedItem;
+  PostMsg(kShiftSelectMessage);
+  _listView.RedrawItem(focusedItem);
+}
+
+void CPanel::OnInsert()
+{
+  /*
+  const int kState = CDIS_MARKED; // LVIS_DROPHILITED;
+  UINT state = (_listView.GetItemState(focusedItem, LVIS_CUT) == 0) ?
+      LVIS_CUT : 0;
+  _listView.SetItemState(focusedItem, state, LVIS_CUT);
+  // _listView.SetItemState_Selected(focusedItem);
+  */
+
+  int focusedItem = _listView.GetFocusedItem();
+  if (focusedItem < 0)
+    return;
+  
+  int realIndex = GetRealItemIndex(focusedItem);
+  if (realIndex != kParentIndex)
+  {
+    bool isSelected = !_selectedStatusVector[realIndex];
+    _selectedStatusVector[realIndex] = isSelected;
+    if (!_mySelectMode)
+      _listView.SetItemState_Selected(focusedItem, isSelected);
+    _listView.RedrawItem(focusedItem);
+  }
+
+  int nextIndex = focusedItem + 1;
+  if (nextIndex < _listView.GetItemCount())
+  {
+    _listView.SetItemState_FocusedSelected(nextIndex);
+    _listView.EnsureVisible(nextIndex, false);
+  }
+}
+
+/*
+void CPanel::OnUpWithShift()
+{
+  int focusedItem = _listView.GetFocusedItem();
+  if (focusedItem < 0)
+    return;
+  int index = GetRealItemIndex(focusedItem);
+  if (index == kParentIndex)
+    return;
+  _selectedStatusVector[index] = !_selectedStatusVector[index];
+  _listView.RedrawItem(index);
+}
+
+void CPanel::OnDownWithShift()
+{
+  int focusedItem = _listView.GetFocusedItem();
+  if (focusedItem < 0)
+    return;
+  int index = GetRealItemIndex(focusedItem);
+  if (index == kParentIndex)
+    return;
+  _selectedStatusVector[index] = !_selectedStatusVector[index];
+  _listView.RedrawItem(index);
+}
+*/
+
+void CPanel::UpdateSelection()
+{
+  if (!_mySelectMode)
+  {
+    bool enableTemp = _enableItemChangeNotify;
+    _enableItemChangeNotify = false;
+    int numItems = _listView.GetItemCount();
+    for (int i = 0; i < numItems; i++)
+    {
+      int realIndex = GetRealItemIndex(i);
+      if (realIndex != kParentIndex)
+        _listView.SetItemState_Selected(i, _selectedStatusVector[realIndex]);
+    }
+    _enableItemChangeNotify = enableTemp;
+  }
+  _listView.RedrawAllItems();
+}
+
+
+void CPanel::SelectSpec(bool selectMode)
+{
+  CComboDialog dlg;
+  LangString(selectMode ? IDS_SELECT : IDS_DESELECT, dlg.Title );
+  LangString(IDS_SELECT_MASK, dlg.Static);
+  dlg.Value = '*';
+  if (dlg.Create(GetParent()) != IDOK)
+    return;
+  const UString &mask = dlg.Value;
+  FOR_VECTOR (i, _selectedStatusVector)
+    if (DoesWildcardMatchName(mask, GetItemName(i)))
+       _selectedStatusVector[i] = selectMode;
+  UpdateSelection();
+}
+
+void CPanel::SelectByType(bool selectMode)
+{
+  int focusedItem = _listView.GetFocusedItem();
+  if (focusedItem < 0)
+    return;
+  int realIndex = GetRealItemIndex(focusedItem);
+  UString name = GetItemName(realIndex);
+  bool isItemFolder = IsItem_Folder(realIndex);
+
+  if (isItemFolder)
+  {
+    FOR_VECTOR (i, _selectedStatusVector)
+      if (IsItem_Folder(i) == isItemFolder)
+        _selectedStatusVector[i] = selectMode;
+  }
+  else
+  {
+    int pos = name.ReverseFind_Dot();
+    if (pos < 0)
+    {
+      FOR_VECTOR (i, _selectedStatusVector)
+        if (IsItem_Folder(i) == isItemFolder && GetItemName(i).ReverseFind_Dot() < 0)
+          _selectedStatusVector[i] = selectMode;
+    }
+    else
+    {
+      UString mask ('*');
+      mask += name.Ptr((unsigned)pos);
+      FOR_VECTOR (i, _selectedStatusVector)
+        if (IsItem_Folder(i) == isItemFolder && DoesWildcardMatchName(mask, GetItemName(i)))
+          _selectedStatusVector[i] = selectMode;
+    }
+  }
+
+  UpdateSelection();
+}
+
+void CPanel::SelectAll(bool selectMode)
+{
+  FOR_VECTOR (i, _selectedStatusVector)
+    _selectedStatusVector[i] = selectMode;
+  UpdateSelection();
+}
+
+void CPanel::InvertSelection()
+{
+  if (!_mySelectMode)
+  {
+    unsigned numSelected = 0;
+    FOR_VECTOR (i, _selectedStatusVector)
+      if (_selectedStatusVector[i])
+        numSelected++;
+    // 17.02: fixed : now we invert item even, if single item is selected
+    /*
+    if (numSelected == 1)
+    {
+      int focused = _listView.GetFocusedItem();
+      if (focused >= 0)
+      {
+        int realIndex = GetRealItemIndex(focused);
+        if (realIndex >= 0)
+          if (_selectedStatusVector[realIndex])
+            _selectedStatusVector[realIndex] = false;
+      }
+    }
+    */
+  }
+  FOR_VECTOR (i, _selectedStatusVector)
+    _selectedStatusVector[i] = !_selectedStatusVector[i];
+  UpdateSelection();
+}
+
+void CPanel::KillSelection()
+{
+  SelectAll(false);
+  // ver 20.01: now we don't like that focused will be selected item.
+  //   So the following code was disabled:
+  /*
+  if (!_mySelectMode)
+  {
+    int focused = _listView.GetFocusedItem();
+    if (focused >= 0)
+    {
+      // CPanel::OnItemChanged notify for LVIS_SELECTED change doesn't work here. Why?
+      // so we change _selectedStatusVector[realIndex] here.
+      int realIndex = GetRealItemIndex(focused);
+      if (realIndex != kParentIndex)
+        _selectedStatusVector[realIndex] = true;
+      _listView.SetItemState_Selected(focused);
+    }
+  }
+  */
+}
+
+void CPanel::OnLeftClick(MY_NMLISTVIEW_NMITEMACTIVATE *itemActivate)
+{
+  if (itemActivate->hdr.hwndFrom != HWND(_listView))
+    return;
+  // It will work only for Version 4.71 (IE 4);
+  int indexInList = itemActivate->iItem;
+  if (indexInList < 0)
+    return;
+  
+  #ifndef UNDER_CE
+  if ((itemActivate->uKeyFlags & LVKF_SHIFT) != 0)
+  {
+    // int focusedIndex = _listView.GetFocusedItem();
+    int focusedIndex = _startGroupSelect;
+    if (focusedIndex < 0)
+      return;
+    int startItem = MyMin(focusedIndex, indexInList);
+    int finishItem = MyMax(focusedIndex, indexInList);
+
+    int numItems = _listView.GetItemCount();
+    for (int i = 0; i < numItems; i++)
+    {
+      int realIndex = GetRealItemIndex(i);
+      if (realIndex == kParentIndex)
+        continue;
+      bool selected = (i >= startItem && i <= finishItem);
+      if (_selectedStatusVector[realIndex] != selected)
+      {
+        _selectedStatusVector[realIndex] = selected;
+        _listView.RedrawItem(i);
+      }
+    }
+  }
+  else
+  #endif
+  {
+    _startGroupSelect = indexInList;
+  
+    #ifndef UNDER_CE
+    if ((itemActivate->uKeyFlags & LVKF_CONTROL) != 0)
+    {
+      int realIndex = GetRealItemIndex(indexInList);
+      if (realIndex != kParentIndex)
+      {
+        _selectedStatusVector[realIndex] = !_selectedStatusVector[realIndex];
+        _listView.RedrawItem(indexInList);
+      }
+    }
+    #endif
+  }
+
+  return;
+}
diff --git a/CPP/7zip/UI/FileManager/PanelSort.cpp b/CPP/7zip/UI/FileManager/PanelSort.cpp
new file mode 100644
index 0000000..d26acb7
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelSort.cpp
@@ -0,0 +1,269 @@
+// PanelSort.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "../../PropID.h"
+
+#include "Panel.h"
+
+using namespace NWindows;
+
+int CompareFileNames_ForFolderList(const wchar_t *s1, const wchar_t *s2)
+{
+  for (;;)
+  {
+    wchar_t c1 = *s1;
+    wchar_t c2 = *s2;
+    if ((c1 >= '0' && c1 <= '9') &&
+        (c2 >= '0' && c2 <= '9'))
+    {
+      for (; *s1 == '0'; s1++);
+      for (; *s2 == '0'; s2++);
+      size_t len1 = 0;
+      size_t len2 = 0;
+      for (; (s1[len1] >= '0' && s1[len1] <= '9'); len1++);
+      for (; (s2[len2] >= '0' && s2[len2] <= '9'); len2++);
+      if (len1 < len2) return -1;
+      if (len1 > len2) return 1;
+      for (; len1 > 0; s1++, s2++, len1--)
+      {
+        if (*s1 == *s2) continue;
+        return (*s1 < *s2) ? -1 : 1;
+      }
+      c1 = *s1;
+      c2 = *s2;
+    }
+    s1++;
+    s2++;
+    if (c1 != c2)
+    {
+      // Probably we need to change the order for special characters like in Explorer.
+      wchar_t u1 = MyCharUpper(c1);
+      wchar_t u2 = MyCharUpper(c2);
+      if (u1 < u2) return -1;
+      if (u1 > u2) return 1;
+    }
+    if (c1 == 0) return 0;
+  }
+}
+
+static int CompareFileNames_Le16(const Byte *s1, unsigned size1, const Byte *s2, unsigned size2)
+{
+  size1 &= ~1;
+  size2 &= ~1;
+  for (unsigned i = 0;; i += 2)
+  {
+    if (i >= size1)
+      return (i >= size2) ? 0 : -1;
+    if (i >= size2)
+      return 1;
+    UInt16 c1 = GetUi16(s1 + i);
+    UInt16 c2 = GetUi16(s2 + i);
+    if (c1 == c2)
+    {
+      if (c1 == 0)
+        return 0;
+      continue;
+    }
+    if (c1 < c2)
+      return -1;
+    return 1;
+  }
+}
+
+static inline const wchar_t *GetExtensionPtr(const UString &name)
+{
+  int dotPos = name.ReverseFind_Dot();
+  return name.Ptr((dotPos < 0) ? name.Len() : dotPos);
+}
+
+void CPanel::SetSortRawStatus()
+{
+  _isRawSortProp = false;
+  FOR_VECTOR (i, _columns)
+  {
+    const CPropColumn &prop = _columns[i];
+    if (prop.ID == _sortID)
+    {
+      _isRawSortProp = prop.IsRawProp ? 1 : 0;
+      return;
+    }
+  }
+}
+
+
+static int CALLBACK CompareItems2(LPARAM lParam1, LPARAM lParam2, LPARAM lpData)
+{
+  if (lpData == 0)
+    return 0;
+  CPanel *panel = (CPanel*)lpData;
+  
+
+  PROPID propID = panel->_sortID;
+
+  if (propID == kpidNoProperty)
+    return MyCompare(lParam1, lParam2);
+
+  if (panel->_isRawSortProp)
+  {
+    // Sha1, NtSecurity, NtReparse
+    const void *data1;
+    const void *data2;
+    UInt32 dataSize1;
+    UInt32 dataSize2;
+    UInt32 propType1;
+    UInt32 propType2;
+    if (panel->_folderRawProps->GetRawProp((UInt32)lParam1, propID, &data1, &dataSize1, &propType1) != 0) return 0;
+    if (panel->_folderRawProps->GetRawProp((UInt32)lParam2, propID, &data2, &dataSize2, &propType2) != 0) return 0;
+    if (dataSize1 == 0)
+      return (dataSize2 == 0) ? 0 : -1;
+    if (dataSize2 == 0)
+      return 1;
+    if (propType1 != NPropDataType::kRaw) return 0;
+    if (propType2 != NPropDataType::kRaw) return 0;
+    if (propID == kpidNtReparse)
+    {
+      NFile::CReparseShortInfo r1; r1.Parse((const Byte *)data1, dataSize1);
+      NFile::CReparseShortInfo r2; r2.Parse((const Byte *)data2, dataSize2);
+      return CompareFileNames_Le16(
+          (const Byte *)data1 + r1.Offset, r1.Size,
+          (const Byte *)data2 + r2.Offset, r2.Size);
+    }
+  }
+
+  if (panel->_folderCompare)
+    return panel->_folderCompare->CompareItems((UInt32)lParam1, (UInt32)lParam2, propID, panel->_isRawSortProp);
+  
+  switch (propID)
+  {
+    // if (panel->_sortIndex == 0)
+    case kpidName:
+    {
+      const UString name1 = panel->GetItemName((int)lParam1);
+      const UString name2 = panel->GetItemName((int)lParam2);
+      int res = CompareFileNames_ForFolderList(name1, name2);
+      /*
+      if (res != 0 || !panel->_flatMode)
+        return res;
+      const UString prefix1 = panel->GetItemPrefix(lParam1);
+      const UString prefix2 = panel->GetItemPrefix(lParam2);
+      return res = CompareFileNames_ForFolderList(prefix1, prefix2);
+      */
+      return res;
+    }
+    case kpidExtension:
+    {
+      const UString name1 = panel->GetItemName((int)lParam1);
+      const UString name2 = panel->GetItemName((int)lParam2);
+      return CompareFileNames_ForFolderList(
+          GetExtensionPtr(name1),
+          GetExtensionPtr(name2));
+    }
+  }
+  /*
+  if (panel->_sortIndex == 1)
+    return MyCompare(file1.Size, file2.Size);
+  return ::CompareFileTime(&file1.MTime, &file2.MTime);
+  */
+
+  // PROPID propID = panel->_columns[panel->_sortIndex].ID;
+
+  NCOM::CPropVariant prop1, prop2;
+  // Name must be first property
+  panel->_folder->GetProperty((UInt32)lParam1, propID, &prop1);
+  panel->_folder->GetProperty((UInt32)lParam2, propID, &prop2);
+  if (prop1.vt != prop2.vt)
+    return MyCompare(prop1.vt, prop2.vt);
+  if (prop1.vt == VT_BSTR)
+    return MyStringCompareNoCase(prop1.bstrVal, prop2.bstrVal);
+  return prop1.Compare(prop2);
+}
+
+int CALLBACK CompareItems(LPARAM lParam1, LPARAM lParam2, LPARAM lpData);
+int CALLBACK CompareItems(LPARAM lParam1, LPARAM lParam2, LPARAM lpData)
+{
+  if (lpData == 0) return 0;
+  if (lParam1 == kParentIndex) return -1;
+  if (lParam2 == kParentIndex) return 1;
+
+  CPanel *panel = (CPanel*)lpData;
+
+  bool isDir1 = panel->IsItem_Folder((int)lParam1);
+  bool isDir2 = panel->IsItem_Folder((int)lParam2);
+  
+  if (isDir1 && !isDir2) return -1;
+  if (isDir2 && !isDir1) return 1;
+
+  int result = CompareItems2(lParam1, lParam2, lpData);
+  return panel->_ascending ? result: (-result);
+}
+
+
+/*
+void CPanel::SortItems(int index)
+{
+  if (index == _sortIndex)
+    _ascending = !_ascending;
+  else
+  {
+    _sortIndex = index;
+    _ascending = true;
+    switch (_columns[_sortIndex].ID)
+    {
+      case kpidSize:
+      case kpidPackedSize:
+      case kpidCTime:
+      case kpidATime:
+      case kpidMTime:
+      _ascending = false;
+      break;
+    }
+  }
+  _listView.SortItems(CompareItems, (LPARAM)this);
+  _listView.EnsureVisible(_listView.GetFocusedItem(), false);
+}
+
+void CPanel::SortItemsWithPropID(PROPID propID)
+{
+  int index = _columns.FindItem_for_PropID(propID);
+  if (index >= 0)
+    SortItems(index);
+}
+*/
+
+void CPanel::SortItemsWithPropID(PROPID propID)
+{
+  if (propID == _sortID)
+    _ascending = !_ascending;
+  else
+  {
+    _sortID = propID;
+    _ascending = true;
+    switch (propID)
+    {
+      case kpidSize:
+      case kpidPackSize:
+      case kpidCTime:
+      case kpidATime:
+      case kpidMTime:
+        _ascending = false;
+      break;
+    }
+  }
+  SetSortRawStatus();
+  _listView.SortItems(CompareItems, (LPARAM)this);
+  _listView.EnsureVisible(_listView.GetFocusedItem(), false);
+}
+
+
+void CPanel::OnColumnClick(LPNMLISTVIEW info)
+{
+  /*
+  int index = _columns.FindItem_for_PropID(_visibleColumns[info->iSubItem].ID);
+  SortItems(index);
+  */
+  SortItemsWithPropID(_visibleColumns[info->iSubItem].ID);
+}
diff --git a/CPP/7zip/UI/FileManager/PanelSplitFile.cpp b/CPP/7zip/UI/FileManager/PanelSplitFile.cpp
new file mode 100644
index 0000000..00a0d80
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelSplitFile.cpp
@@ -0,0 +1,562 @@
+// PanelSplitFile.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileName.h"
+
+#include "../GUI/ExtractRes.h"
+
+#include "resource.h"
+
+#include "App.h"
+#include "CopyDialog.h"
+#include "FormatUtils.h"
+#include "LangUtils.h"
+#include "SplitDialog.h"
+#include "SplitUtils.h"
+
+#include "PropertyNameRes.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+static const char * const g_Message_FileWriteError = "File write error";
+
+struct CVolSeqName
+{
+  UString UnchangedPart;
+  UString ChangedPart;
+  CVolSeqName(): ChangedPart("000") {};
+
+  void SetNumDigits(UInt64 numVolumes)
+  {
+    ChangedPart = "000";
+    while (numVolumes > 999)
+    {
+      numVolumes /= 10;
+      ChangedPart += '0';
+    }
+  }
+
+  bool ParseName(const UString &name)
+  {
+    if (name.Len() < 2)
+      return false;
+    if (name.Back() != L'1' || name[name.Len() - 2] != L'0')
+      return false;
+
+    unsigned pos = name.Len() - 2;
+    for (; pos > 0 && name[pos - 1] == '0'; pos--);
+    UnchangedPart.SetFrom(name, pos);
+    ChangedPart = name.Ptr(pos);
+    return true;
+  }
+
+  UString GetNextName();
+};
+
+
+UString CVolSeqName::GetNextName()
+{
+  for (int i = (int)ChangedPart.Len() - 1; i >= 0; i--)
+  {
+    wchar_t c = ChangedPart[i];
+    if (c != L'9')
+    {
+      ChangedPart.ReplaceOneCharAtPos(i, (wchar_t)(c + 1));
+      break;
+    }
+    ChangedPart.ReplaceOneCharAtPos(i, L'0');
+    if (i == 0)
+      ChangedPart.InsertAtFront(L'1');
+  }
+  return UnchangedPart + ChangedPart;
+}
+
+class CThreadSplit: public CProgressThreadVirt
+{
+  HRESULT ProcessVirt();
+public:
+  FString FilePath;
+  FString VolBasePath;
+  UInt64 NumVolumes;
+  CRecordVector<UInt64> VolumeSizes;
+};
+
+
+class CPreAllocOutFile
+{
+  UInt64 _preAllocSize;
+public:
+  NIO::COutFile File;
+  UInt64 Written;
+  
+  CPreAllocOutFile(): _preAllocSize(0), Written(0) {}
+  
+  ~CPreAllocOutFile()
+  {
+    SetCorrectFileLength();
+  }
+
+  void PreAlloc(UInt64 preAllocSize)
+  {
+    _preAllocSize = 0;
+    if (File.SetLength(preAllocSize))
+      _preAllocSize = preAllocSize;
+    File.SeekToBegin();
+  }
+
+  bool Write(const void *data, UInt32 size, UInt32 &processedSize) throw()
+  {
+    bool res = File.Write(data, size, processedSize);
+    Written += processedSize;
+    return res;
+  }
+
+  void Close()
+  {
+    SetCorrectFileLength();
+    Written = 0;
+    _preAllocSize = 0;
+    File.Close();
+  }
+
+  void SetCorrectFileLength()
+  {
+    if (Written < _preAllocSize)
+    {
+      File.SetLength(Written);
+      _preAllocSize = 0;
+    }
+  }
+};
+
+
+static const UInt32 kBufSize = (1 << 20);
+
+HRESULT CThreadSplit::ProcessVirt()
+{
+  NIO::CInFile inFile;
+  if (!inFile.Open(FilePath))
+    return GetLastError();
+
+  CPreAllocOutFile outFile;
+  
+  CMyBuffer buffer;
+  if (!buffer.Allocate(kBufSize))
+    return E_OUTOFMEMORY;
+  
+  CVolSeqName seqName;
+  seqName.SetNumDigits(NumVolumes);
+  
+  UInt64 length;
+  if (!inFile.GetLength(length))
+    return GetLastError();
+  
+  CProgressSync &sync = Sync;
+  sync.Set_NumBytesTotal(length);
+  
+  UInt64 pos = 0;
+  UInt64 prev = 0;
+  UInt64 numFiles = 0;
+  unsigned volIndex = 0;
+
+  for (;;)
+  {
+    UInt64 volSize;
+    if (volIndex < VolumeSizes.Size())
+      volSize = VolumeSizes[volIndex];
+    else
+      volSize = VolumeSizes.Back();
+    
+    UInt32 needSize = kBufSize;
+    {
+      const UInt64 rem = volSize - outFile.Written;
+      if (needSize > rem)
+        needSize = (UInt32)rem;
+    }
+    UInt32 processedSize;
+    if (!inFile.Read(buffer, needSize, processedSize))
+      return GetLastError();
+    if (processedSize == 0)
+      return S_OK;
+    needSize = processedSize;
+  
+    if (outFile.Written == 0)
+    {
+      FString name = VolBasePath;
+      name += '.';
+      name += us2fs(seqName.GetNextName());
+      sync.Set_FilePath(fs2us(name));
+      if (!outFile.File.Create(name, false))
+      {
+        HRESULT res = GetLastError();
+        AddErrorPath(name);
+        return res;
+      }
+      UInt64 expectSize = volSize;
+      if (pos < length)
+      {
+        const UInt64 rem = length - pos;
+        if (expectSize > rem)
+          expectSize = rem;
+      }
+      outFile.PreAlloc(expectSize);
+    }
+    
+    if (!outFile.Write(buffer, needSize, processedSize))
+      return GetLastError();
+    if (needSize != processedSize)
+      throw g_Message_FileWriteError;
+    
+    pos += processedSize;
+    
+    if (outFile.Written == volSize)
+    {
+      outFile.Close();
+      sync.Set_NumFilesCur(++numFiles);
+      if (volIndex < VolumeSizes.Size())
+        volIndex++;
+    }
+
+    if (pos - prev >= ((UInt32)1 << 22) || outFile.Written == 0)
+    {
+      RINOK(sync.Set_NumBytesCur(pos));
+      prev = pos;
+    }
+  }
+}
+
+
+void CApp::Split()
+{
+  int srcPanelIndex = GetFocusedPanelIndex();
+  CPanel &srcPanel = Panels[srcPanelIndex];
+  if (!srcPanel.Is_IO_FS_Folder())
+  {
+    srcPanel.MessageBox_Error_UnsupportOperation();
+    return;
+  }
+  CRecordVector<UInt32> indices;
+  srcPanel.GetOperatedItemIndices(indices);
+  if (indices.IsEmpty())
+    return;
+  if (indices.Size() != 1)
+  {
+    srcPanel.MessageBox_Error_LangID(IDS_SELECT_ONE_FILE);
+    return;
+  }
+  int index = indices[0];
+  if (srcPanel.IsItem_Folder(index))
+  {
+    srcPanel.MessageBox_Error_LangID(IDS_SELECT_ONE_FILE);
+    return;
+  }
+  const UString itemName = srcPanel.GetItemName(index);
+
+  UString srcPath = srcPanel.GetFsPath() + srcPanel.GetItemPrefix(index);
+  UString path = srcPath;
+  unsigned destPanelIndex = (NumPanels <= 1) ? srcPanelIndex : (1 - srcPanelIndex);
+  CPanel &destPanel = Panels[destPanelIndex];
+  if (NumPanels > 1)
+    if (destPanel.IsFSFolder())
+      path = destPanel.GetFsPath();
+  CSplitDialog splitDialog;
+  splitDialog.FilePath = srcPanel.GetItemRelPath(index);
+  splitDialog.Path = path;
+  if (splitDialog.Create(srcPanel.GetParent()) != IDOK)
+    return;
+
+  NFind::CFileInfo fileInfo;
+  if (!fileInfo.Find(us2fs(srcPath + itemName)))
+  {
+    srcPanel.MessageBox_Error(L"Cannot find file");
+    return;
+  }
+  if (fileInfo.Size <= splitDialog.VolumeSizes.Front())
+  {
+    srcPanel.MessageBox_Error_LangID(IDS_SPLIT_VOL_MUST_BE_SMALLER);
+    return;
+  }
+  const UInt64 numVolumes = GetNumberOfVolumes(fileInfo.Size, splitDialog.VolumeSizes);
+  if (numVolumes >= 100)
+  {
+    wchar_t s[32];
+    ConvertUInt64ToString(numVolumes, s);
+    if (::MessageBoxW(srcPanel, MyFormatNew(IDS_SPLIT_CONFIRM_MESSAGE, s),
+        LangString(IDS_SPLIT_CONFIRM_TITLE),
+        MB_YESNOCANCEL | MB_ICONQUESTION) != IDYES)
+      return;
+  }
+
+  path = splitDialog.Path;
+  NName::NormalizeDirPathPrefix(path);
+  if (!CreateComplexDir(us2fs(path)))
+  {
+    DWORD lastError = ::GetLastError();
+    srcPanel.MessageBox_Error_2Lines_Message_HRESULT(MyFormatNew(IDS_CANNOT_CREATE_FOLDER, path), lastError);
+    return;
+  }
+
+  {
+  CThreadSplit spliter;
+  spliter.NumVolumes = numVolumes;
+
+  CProgressDialog &progressDialog = spliter;
+
+  UString progressWindowTitle ("7-Zip"); // LangString(IDS_APP_TITLE, 0x03000000);
+  UString title = LangString(IDS_SPLITTING);
+
+  progressDialog.ShowCompressionInfo = false;
+
+  progressDialog.MainWindow = _window;
+  progressDialog.MainTitle = progressWindowTitle;
+  progressDialog.MainAddTitle = title;
+  progressDialog.MainAddTitle.Add_Space();
+  progressDialog.Sync.Set_TitleFileName(itemName);
+
+
+  spliter.FilePath = us2fs(srcPath + itemName);
+  spliter.VolBasePath = us2fs(path + srcPanel.GetItemName_for_Copy(index));
+  spliter.VolumeSizes = splitDialog.VolumeSizes;
+  
+  // if (splitDialog.VolumeSizes.Size() == 0) return;
+
+  // CPanel::CDisableTimerProcessing disableTimerProcessing1(srcPanel);
+  // CPanel::CDisableTimerProcessing disableTimerProcessing2(destPanel);
+
+  if (spliter.Create(title, _window) != 0)
+    return;
+  }
+  RefreshTitleAlways();
+
+
+  // disableNotify.Restore();
+  // disableNotify.Restore();
+  // srcPanel.SetFocusToList();
+  // srcPanel.RefreshListCtrlSaveFocused();
+}
+
+
+class CThreadCombine: public CProgressThreadVirt
+{
+  HRESULT ProcessVirt();
+public:
+  FString InputDirPrefix;
+  FStringVector Names;
+  FString OutputPath;
+  UInt64 TotalSize;
+};
+
+HRESULT CThreadCombine::ProcessVirt()
+{
+  NIO::COutFile outFile;
+  if (!outFile.Create(OutputPath, false))
+  {
+    HRESULT res = GetLastError();
+    AddErrorPath(OutputPath);
+    return res;
+  }
+  
+  CProgressSync &sync = Sync;
+  sync.Set_NumBytesTotal(TotalSize);
+  
+  CMyBuffer bufferObject;
+  if (!bufferObject.Allocate(kBufSize))
+    return E_OUTOFMEMORY;
+  Byte *buffer = (Byte *)(void *)bufferObject;
+  UInt64 pos = 0;
+  FOR_VECTOR (i, Names)
+  {
+    NIO::CInFile inFile;
+    const FString nextName = InputDirPrefix + Names[i];
+    if (!inFile.Open(nextName))
+    {
+      HRESULT res = GetLastError();
+      AddErrorPath(nextName);
+      return res;
+    }
+    sync.Set_FilePath(fs2us(nextName));
+    for (;;)
+    {
+      UInt32 processedSize;
+      if (!inFile.Read(buffer, kBufSize, processedSize))
+      {
+        HRESULT res = GetLastError();
+        AddErrorPath(nextName);
+        return res;
+      }
+      if (processedSize == 0)
+        break;
+      UInt32 needSize = processedSize;
+      if (!outFile.Write(buffer, needSize, processedSize))
+      {
+        HRESULT res = GetLastError();
+        AddErrorPath(OutputPath);
+        return res;
+      }
+      if (needSize != processedSize)
+        throw g_Message_FileWriteError;
+      pos += processedSize;
+      RINOK(sync.Set_NumBytesCur(pos));
+    }
+  }
+  return S_OK;
+}
+
+extern void AddValuePair2(UString &s, UINT resourceID, UInt64 num, UInt64 size);
+
+static void AddInfoFileName(UString &dest, const UString &name)
+{
+  dest += "\n  ";
+  dest += name;
+}
+
+void CApp::Combine()
+{
+  int srcPanelIndex = GetFocusedPanelIndex();
+  CPanel &srcPanel = Panels[srcPanelIndex];
+  if (!srcPanel.IsFSFolder())
+  {
+    srcPanel.MessageBox_Error_LangID(IDS_OPERATION_IS_NOT_SUPPORTED);
+    return;
+  }
+  CRecordVector<UInt32> indices;
+  srcPanel.GetOperatedItemIndices(indices);
+  if (indices.IsEmpty())
+    return;
+  int index = indices[0];
+  if (indices.Size() != 1 || srcPanel.IsItem_Folder(index))
+  {
+    srcPanel.MessageBox_Error_LangID(IDS_COMBINE_SELECT_ONE_FILE);
+    return;
+  }
+  const UString itemName = srcPanel.GetItemName(index);
+
+  UString srcPath = srcPanel.GetFsPath() + srcPanel.GetItemPrefix(index);
+  UString path = srcPath;
+  unsigned destPanelIndex = (NumPanels <= 1) ? srcPanelIndex : (1 - srcPanelIndex);
+  CPanel &destPanel = Panels[destPanelIndex];
+  if (NumPanels > 1)
+    if (destPanel.IsFSFolder())
+      path = destPanel.GetFsPath();
+
+  CVolSeqName volSeqName;
+  if (!volSeqName.ParseName(itemName))
+  {
+    srcPanel.MessageBox_Error_LangID(IDS_COMBINE_CANT_DETECT_SPLIT_FILE);
+    return;
+  }
+  
+  {
+  CThreadCombine combiner;
+  
+  UString nextName = itemName;
+  combiner.TotalSize = 0;
+  for (;;)
+  {
+    NFind::CFileInfo fileInfo;
+    if (!fileInfo.Find(us2fs(srcPath + nextName)) || fileInfo.IsDir())
+      break;
+    combiner.Names.Add(us2fs(nextName));
+    combiner.TotalSize += fileInfo.Size;
+    nextName = volSeqName.GetNextName();
+  }
+  if (combiner.Names.Size() == 1)
+  {
+    srcPanel.MessageBox_Error_LangID(IDS_COMBINE_CANT_FIND_MORE_THAN_ONE_PART);
+    return;
+  }
+  
+  if (combiner.TotalSize == 0)
+  {
+    srcPanel.MessageBox_Error(L"No data");
+    return;
+  }
+  
+  UString info;
+  AddValuePair2(info, IDS_PROP_FILES, combiner.Names.Size(), combiner.TotalSize);
+  
+  info.Add_LF();
+  info += srcPath;
+  
+  unsigned i;
+  for (i = 0; i < combiner.Names.Size() && i < 2; i++)
+    AddInfoFileName(info, fs2us(combiner.Names[i]));
+  if (i != combiner.Names.Size())
+  {
+    if (i + 1 != combiner.Names.Size())
+      AddInfoFileName(info, L"...");
+    AddInfoFileName(info, fs2us(combiner.Names.Back()));
+  }
+  
+  {
+    CCopyDialog copyDialog;
+    copyDialog.Value = path;
+    LangString(IDS_COMBINE, copyDialog.Title);
+    copyDialog.Title.Add_Space();
+    copyDialog.Title += srcPanel.GetItemRelPath(index);
+    LangString(IDS_COMBINE_TO, copyDialog.Static);
+    copyDialog.Info = info;
+    if (copyDialog.Create(srcPanel.GetParent()) != IDOK)
+      return;
+    path = copyDialog.Value;
+  }
+
+  NName::NormalizeDirPathPrefix(path);
+  if (!CreateComplexDir(us2fs(path)))
+  {
+    DWORD lastError = ::GetLastError();
+    srcPanel.MessageBox_Error_2Lines_Message_HRESULT(MyFormatNew(IDS_CANNOT_CREATE_FOLDER, path), lastError);
+    return;
+  }
+  
+  UString outName = volSeqName.UnchangedPart;
+  while (!outName.IsEmpty())
+  {
+    if (outName.Back() != L'.')
+      break;
+    outName.DeleteBack();
+  }
+  if (outName.IsEmpty())
+    outName = "file";
+  
+  NFind::CFileInfo fileInfo;
+  UString destFilePath = path + outName;
+  combiner.OutputPath = us2fs(destFilePath);
+  if (fileInfo.Find(combiner.OutputPath))
+  {
+    srcPanel.MessageBox_Error(MyFormatNew(IDS_FILE_EXIST, destFilePath));
+    return;
+  }
+  
+    CProgressDialog &progressDialog = combiner;
+    progressDialog.ShowCompressionInfo = false;
+  
+    UString progressWindowTitle ("7-Zip"); // LangString(IDS_APP_TITLE, 0x03000000);
+    UString title = LangString(IDS_COMBINING);
+    
+    progressDialog.MainWindow = _window;
+    progressDialog.MainTitle = progressWindowTitle;
+    progressDialog.MainAddTitle = title;
+    progressDialog.MainAddTitle.Add_Space();
+    
+    combiner.InputDirPrefix = us2fs(srcPath);
+    
+    // CPanel::CDisableTimerProcessing disableTimerProcessing1(srcPanel);
+    // CPanel::CDisableTimerProcessing disableTimerProcessing2(destPanel);
+    
+    if (combiner.Create(title, _window) != 0)
+      return;
+  }
+  RefreshTitleAlways();
+
+  // disableNotify.Restore();
+  // disableNotify.Restore();
+  // srcPanel.SetFocusToList();
+  // srcPanel.RefreshListCtrlSaveFocused();
+}
diff --git a/CPP/7zip/UI/FileManager/PasswordDialog.cpp b/CPP/7zip/UI/FileManager/PasswordDialog.cpp
new file mode 100644
index 0000000..6ead39c
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PasswordDialog.cpp
@@ -0,0 +1,58 @@
+// PasswordDialog.cpp
+
+#include "StdAfx.h"
+
+#include "PasswordDialog.h"
+
+#ifdef LANG
+#include "LangUtils.h"
+#endif
+
+#ifdef LANG
+static const UInt32 kLangIDs[] =
+{
+  IDT_PASSWORD_ENTER,
+  IDX_PASSWORD_SHOW
+};
+#endif
+
+void CPasswordDialog::ReadControls()
+{
+  _passwordEdit.GetText(Password);
+  ShowPassword = IsButtonCheckedBool(IDX_PASSWORD_SHOW);
+}
+
+void CPasswordDialog::SetTextSpec()
+{
+  _passwordEdit.SetPasswordChar(ShowPassword ? 0: TEXT('*'));
+  _passwordEdit.SetText(Password);
+}
+
+bool CPasswordDialog::OnInit()
+{
+  #ifdef LANG
+  LangSetWindowText(*this, IDD_PASSWORD);
+  LangSetDlgItems(*this, kLangIDs, ARRAY_SIZE(kLangIDs));
+  #endif
+  _passwordEdit.Attach(GetItem(IDE_PASSWORD_PASSWORD));
+  CheckButton(IDX_PASSWORD_SHOW, ShowPassword);
+  SetTextSpec();
+  return CModalDialog::OnInit();
+}
+
+bool CPasswordDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
+{
+  if (buttonID == IDX_PASSWORD_SHOW)
+  {
+    ReadControls();
+    SetTextSpec();
+    return true;
+  }
+  return CDialog::OnButtonClicked(buttonID, buttonHWND);
+}
+
+void CPasswordDialog::OnOK()
+{
+  ReadControls();
+  CModalDialog::OnOK();
+}
diff --git a/CPP/7zip/UI/FileManager/PasswordDialog.h b/CPP/7zip/UI/FileManager/PasswordDialog.h
new file mode 100644
index 0000000..339ebda
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PasswordDialog.h
@@ -0,0 +1,28 @@
+// PasswordDialog.h
+
+#ifndef __PASSWORD_DIALOG_H
+#define __PASSWORD_DIALOG_H
+
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/Edit.h"
+
+#include "PasswordDialogRes.h"
+
+class CPasswordDialog: public NWindows::NControl::CModalDialog
+{
+  NWindows::NControl::CEdit _passwordEdit;
+
+  virtual void OnOK();
+  virtual bool OnInit();
+  virtual bool OnButtonClicked(int buttonID, HWND buttonHWND);
+  void SetTextSpec();
+  void ReadControls();
+public:
+  UString Password;
+  bool ShowPassword;
+  
+  CPasswordDialog(): ShowPassword(false) {}
+  INT_PTR Create(HWND parentWindow = 0) { return CModalDialog::Create(IDD_PASSWORD, parentWindow); }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/PasswordDialog.rc b/CPP/7zip/UI/FileManager/PasswordDialog.rc
new file mode 100644
index 0000000..90c57ef
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PasswordDialog.rc
@@ -0,0 +1,14 @@
+#include "PasswordDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 140
+#define yc 72
+
+IDD_PASSWORD  DIALOG  0, 0, xs, ys  MY_MODAL_DIALOG_STYLE  MY_FONT
+CAPTION "Enter password"
+BEGIN
+  LTEXT    "&Enter password:", IDT_PASSWORD_ENTER, m, m, xc, 8
+  EDITTEXT  IDE_PASSWORD_PASSWORD, m, 20, xc, 14, ES_PASSWORD | ES_AUTOHSCROLL
+  CONTROL  "&Show password", IDX_PASSWORD_SHOW, MY_CHECKBOX, m, 42, xc, 10
+  OK_CANCEL
+END
diff --git a/CPP/7zip/UI/FileManager/PasswordDialogRes.h b/CPP/7zip/UI/FileManager/PasswordDialogRes.h
new file mode 100644
index 0000000..1fe32e1
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PasswordDialogRes.h
@@ -0,0 +1,5 @@
+#define IDD_PASSWORD        3800
+#define IDT_PASSWORD_ENTER  3801
+#define IDX_PASSWORD_SHOW   3803
+
+#define IDE_PASSWORD_PASSWORD  120
diff --git a/CPP/7zip/UI/FileManager/PluginInterface.h b/CPP/7zip/UI/FileManager/PluginInterface.h
new file mode 100644
index 0000000..37654a0
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PluginInterface.h
@@ -0,0 +1,31 @@
+// PluginInterface.h
+
+#ifndef __PLUGIN_INTERFACE_H
+#define __PLUGIN_INTERFACE_H
+
+/*
+#include "../../../Common/Types.h"
+#include "../../IDecl.h"
+
+#define PLUGIN_INTERFACE(i, x) DECL_INTERFACE(i, 0x0A, x)
+
+PLUGIN_INTERFACE(IInitContextMenu, 0x00)
+{
+  STDMETHOD(InitContextMenu)(const wchar_t *folder, const wchar_t * const *names, UInt32 numFiles) PURE;
+};
+
+PLUGIN_INTERFACE(IPluginOptionsCallback, 0x01)
+{
+  STDMETHOD(GetProgramFolderPath)(BSTR *value) PURE;
+  STDMETHOD(GetProgramPath)(BSTR *value) PURE;
+  STDMETHOD(GetRegistryCUPath)(BSTR *value) PURE;
+};
+
+PLUGIN_INTERFACE(IPluginOptions, 0x02)
+{
+  STDMETHOD(PluginOptions)(HWND hWnd, IPluginOptionsCallback *callback) PURE;
+  // STDMETHOD(GetFileExtensions)(BSTR *extensions) PURE;
+};
+*/
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/PluginLoader.h b/CPP/7zip/UI/FileManager/PluginLoader.h
new file mode 100644
index 0000000..fed38d6
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PluginLoader.h
@@ -0,0 +1,28 @@
+// PluginLoader.h
+
+#ifndef __PLUGIN_LOADER_H
+#define __PLUGIN_LOADER_H
+
+#include "../../../Windows/DLL.h"
+
+#include "IFolder.h"
+
+class CPluginLibrary: public NWindows::NDLL::CLibrary
+{
+public:
+  HRESULT CreateManager(REFGUID clsID, IFolderManager **manager)
+  {
+    Func_CreateObject createObject = (Func_CreateObject)GetProc("CreateObject");
+    if (!createObject)
+      return GetLastError();
+    return createObject(&clsID, &IID_IFolderManager, (void **)manager);
+  }
+  HRESULT LoadAndCreateManager(CFSTR filePath, REFGUID clsID, IFolderManager **manager)
+  {
+    if (!Load(filePath))
+      return GetLastError();
+    return CreateManager(clsID, manager);
+  }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/ProgramLocation.cpp b/CPP/7zip/UI/FileManager/ProgramLocation.cpp
new file mode 100644
index 0000000..50ca5ca
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ProgramLocation.cpp
@@ -0,0 +1,3 @@
+// ProgramLocation.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/UI/FileManager/ProgramLocation.h b/CPP/7zip/UI/FileManager/ProgramLocation.h
new file mode 100644
index 0000000..6bfb711
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ProgramLocation.h
@@ -0,0 +1,6 @@
+// ProgramLocation.h
+
+#ifndef __PROGRAM_LOCATION_H
+#define __PROGRAM_LOCATION_H
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/ProgressDialog.cpp b/CPP/7zip/UI/FileManager/ProgressDialog.cpp
new file mode 100644
index 0000000..b688a90
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ProgressDialog.cpp
@@ -0,0 +1,199 @@
+// ProgressDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+
+#include "resource.h"
+
+#include "ProgressDialog.h"
+
+using namespace NWindows;
+
+extern HINSTANCE g_hInstance;
+
+static const UINT_PTR kTimerID = 3;
+static const UINT kTimerElapse = 100;
+
+#ifdef LANG
+#include "LangUtils.h"
+#endif
+
+HRESULT CProgressSync::ProcessStopAndPause()
+{
+  for (;;)
+  {
+    if (GetStopped())
+      return E_ABORT;
+    if (!GetPaused())
+      break;
+    ::Sleep(100);
+  }
+  return S_OK;
+}
+
+#ifndef _SFX
+CProgressDialog::~CProgressDialog()
+{
+  AddToTitle(L"");
+}
+void CProgressDialog::AddToTitle(LPCWSTR s)
+{
+  if (MainWindow != 0)
+    MySetWindowText(MainWindow, UString(s) + MainTitle);
+}
+#endif
+
+
+bool CProgressDialog::OnInit()
+{
+  _range = (UInt64)(Int64)-1;
+  _prevPercentValue = -1;
+
+  _wasCreated = true;
+  _dialogCreatedEvent.Set();
+
+  #ifdef LANG
+  LangSetDlgItems(*this, NULL, 0);
+  #endif
+
+  m_ProgressBar.Attach(GetItem(IDC_PROGRESS1));
+
+  if (IconID >= 0)
+  {
+    HICON icon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IconID));
+    SetIcon(ICON_BIG, icon);
+  }
+
+  _timer = SetTimer(kTimerID, kTimerElapse);
+  SetText(_title);
+  CheckNeedClose();
+  return CModalDialog::OnInit();
+}
+
+void CProgressDialog::OnCancel() { Sync.SetStopped(true); }
+void CProgressDialog::OnOK() { }
+
+void CProgressDialog::SetRange(UInt64 range)
+{
+  _range = range;
+  _peviousPos = (UInt64)(Int64)-1;
+  _converter.Init(range);
+  m_ProgressBar.SetRange32(0 , _converter.Count(range)); // Test it for 100%
+}
+
+void CProgressDialog::SetPos(UInt64 pos)
+{
+  bool redraw = true;
+  if (pos < _range && pos > _peviousPos)
+  {
+    UInt64 posDelta = pos - _peviousPos;
+    if (posDelta < (_range >> 10))
+      redraw = false;
+  }
+  if (redraw)
+  {
+    m_ProgressBar.SetPos(_converter.Count(pos));  // Test it for 100%
+    _peviousPos = pos;
+  }
+}
+
+bool CProgressDialog::OnTimer(WPARAM /* timerID */, LPARAM /* callback */)
+{
+  if (Sync.GetPaused())
+    return true;
+
+  CheckNeedClose();
+
+  UInt64 total, completed;
+  Sync.GetProgress(total, completed);
+  if (total != _range)
+    SetRange(total);
+  SetPos(completed);
+
+  if (total == 0)
+    total = 1;
+
+  int percentValue = (int)(completed * 100 / total);
+  if (percentValue != _prevPercentValue)
+  {
+    wchar_t s[64];
+    ConvertUInt64ToString(percentValue, s);
+    UString title = s;
+    title += "% ";
+    SetText(title + _title);
+    #ifndef _SFX
+    AddToTitle(title + MainAddTitle);
+    #endif
+    _prevPercentValue = percentValue;
+  }
+  return true;
+}
+
+bool CProgressDialog::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+  switch (message)
+  {
+    case kCloseMessage:
+    {
+      if (_timer)
+      {
+        KillTimer(kTimerID);
+        _timer = 0;
+      }
+      if (_inCancelMessageBox)
+      {
+        _externalCloseMessageWasReceived = true;
+        break;
+      }
+      return OnExternalCloseMessage();
+    }
+    /*
+    case WM_SETTEXT:
+    {
+      if (_timer == 0)
+        return true;
+    }
+    */
+  }
+  return CModalDialog::OnMessage(message, wParam, lParam);
+}
+
+bool CProgressDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
+{
+  switch (buttonID)
+  {
+    case IDCANCEL:
+    {
+      bool paused = Sync.GetPaused();
+      Sync.SetPaused(true);
+      _inCancelMessageBox = true;
+      int res = ::MessageBoxW(*this, L"Are you sure you want to cancel?", _title, MB_YESNOCANCEL);
+      _inCancelMessageBox = false;
+      Sync.SetPaused(paused);
+      if (res == IDCANCEL || res == IDNO)
+      {
+        if (_externalCloseMessageWasReceived)
+          OnExternalCloseMessage();
+        return true;
+      }
+      break;
+    }
+  }
+  return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+}
+
+void CProgressDialog::CheckNeedClose()
+{
+  if (_needClose)
+  {
+    PostMsg(kCloseMessage);
+    _needClose = false;
+  }
+}
+
+bool CProgressDialog::OnExternalCloseMessage()
+{
+  End(0);
+  return true;
+}
diff --git a/CPP/7zip/UI/FileManager/ProgressDialog.h b/CPP/7zip/UI/FileManager/ProgressDialog.h
new file mode 100644
index 0000000..35c182a
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ProgressDialog.h
@@ -0,0 +1,170 @@
+// ProgressDialog.h
+
+#ifndef __PROGRESS_DIALOG_H
+#define __PROGRESS_DIALOG_H
+
+#include "../../../Windows/Synchronization.h"
+#include "../../../Windows/Thread.h"
+
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/ProgressBar.h"
+
+#include "ProgressDialogRes.h"
+
+class CProgressSync
+{
+  NWindows::NSynchronization::CCriticalSection _cs;
+  bool _stopped;
+  bool _paused;
+  UInt64 _total;
+  UInt64 _completed;
+public:
+  CProgressSync(): _stopped(false), _paused(false), _total(1), _completed(0) {}
+
+  HRESULT ProcessStopAndPause();
+  bool GetStopped()
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+    return _stopped;
+  }
+  void SetStopped(bool value)
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+    _stopped = value;
+  }
+  bool GetPaused()
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+    return _paused;
+  }
+  void SetPaused(bool value)
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+    _paused = value;
+  }
+  void SetProgress(UInt64 total, UInt64 completed)
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+    _total = total;
+    _completed = completed;
+  }
+  void SetPos(UInt64 completed)
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+    _completed = completed;
+  }
+  void GetProgress(UInt64 &total, UInt64 &completed)
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+    total = _total;
+    completed = _completed;
+  }
+};
+
+class CU64ToI32Converter
+{
+  UInt64 _numShiftBits;
+public:
+  void Init(UInt64 range)
+  {
+    // Windows CE doesn't like big number here.
+    for (_numShiftBits = 0; range > (1 << 15); _numShiftBits++)
+      range >>= 1;
+  }
+  int Count(UInt64 value) { return int(value >> _numShiftBits); }
+};
+
+class CProgressDialog: public NWindows::NControl::CModalDialog
+{
+private:
+  UINT_PTR _timer;
+
+  UString _title;
+  CU64ToI32Converter _converter;
+  UInt64 _peviousPos;
+  UInt64 _range;
+  NWindows::NControl::CProgressBar m_ProgressBar;
+
+  int _prevPercentValue;
+
+  bool _wasCreated;
+  bool _needClose;
+  bool _inCancelMessageBox;
+  bool _externalCloseMessageWasReceived;
+
+  bool OnTimer(WPARAM timerID, LPARAM callback);
+  void SetRange(UInt64 range);
+  void SetPos(UInt64 pos);
+  virtual bool OnInit();
+  virtual void OnCancel();
+  virtual void OnOK();
+  NWindows::NSynchronization::CManualResetEvent _dialogCreatedEvent;
+  #ifndef _SFX
+  void AddToTitle(LPCWSTR string);
+  #endif
+  bool OnButtonClicked(int buttonID, HWND buttonHWND);
+
+  void WaitCreating() { _dialogCreatedEvent.Lock(); }
+  void CheckNeedClose();
+  bool OnExternalCloseMessage();
+public:
+  CProgressSync Sync;
+  int IconID;
+
+  #ifndef _SFX
+  HWND MainWindow;
+  UString MainTitle;
+  UString MainAddTitle;
+  ~CProgressDialog();
+  #endif
+
+  CProgressDialog(): _timer(0)
+    #ifndef _SFX
+    ,MainWindow(0)
+    #endif
+  {
+    IconID = -1;
+    _wasCreated = false;
+    _needClose = false;
+    _inCancelMessageBox = false;
+    _externalCloseMessageWasReceived = false;
+
+    if (_dialogCreatedEvent.Create() != S_OK)
+      throw 1334987;
+  }
+
+  INT_PTR Create(const UString &title, NWindows::CThread &thread, HWND wndParent = 0)
+  {
+    _title = title;
+    INT_PTR res = CModalDialog::Create(IDD_PROGRESS, wndParent);
+    thread.Wait_Close();
+    return res;
+  }
+
+  enum
+  {
+    kCloseMessage = WM_APP + 1
+  };
+
+  virtual bool OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
+
+  void ProcessWasFinished()
+  {
+    WaitCreating();
+    if (_wasCreated)
+      PostMsg(kCloseMessage);
+    else
+      _needClose = true;
+  };
+};
+
+
+class CProgressCloser
+{
+  CProgressDialog *_p;
+public:
+  CProgressCloser(CProgressDialog &p) : _p(&p) {}
+  ~CProgressCloser() { _p->ProcessWasFinished(); }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/ProgressDialog.rc b/CPP/7zip/UI/FileManager/ProgressDialog.rc
new file mode 100644
index 0000000..55d9923
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ProgressDialog.rc
@@ -0,0 +1,12 @@
+#include "ProgressDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 172
+#define yc 44
+
+IDD_PROGRESS  DIALOG  0, 0, xs, ys  MY_MODAL_DIALOG_STYLE  MY_FONT
+CAPTION "Progress"
+BEGIN
+  PUSHBUTTON  "Cancel", IDCANCEL, bx, by, bxs, bys
+  CONTROL     "Progress1", IDC_PROGRESS1, "msctls_progress32", PBS_SMOOTH | WS_BORDER, m, m, xc, 14
+END
diff --git a/CPP/7zip/UI/FileManager/ProgressDialog2.cpp b/CPP/7zip/UI/FileManager/ProgressDialog2.cpp
new file mode 100644
index 0000000..54273d0
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ProgressDialog2.cpp
@@ -0,0 +1,1460 @@
+// ProgressDialog2.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/Clipboard.h"
+#include "../../../Windows/ErrorMsg.h"
+
+#include "../GUI/ExtractRes.h"
+
+#include "LangUtils.h"
+
+#include "DialogSize.h"
+#include "ProgressDialog2.h"
+#include "ProgressDialog2Res.h"
+
+using namespace NWindows;
+
+extern HINSTANCE g_hInstance;
+
+static const UINT_PTR kTimerID = 3;
+
+static const UINT kCloseMessage = WM_APP + 1;
+// we can't use WM_USER, since WM_USER can be used by standard Windows procedure for Dialog
+
+static const UINT kTimerElapse =
+  #ifdef UNDER_CE
+  500
+  #else
+  200
+  #endif
+  ;
+
+static const UINT kCreateDelay =
+  #ifdef UNDER_CE
+  2500
+  #else
+  500
+  #endif
+  ;
+
+static const DWORD kPauseSleepTime = 100;
+
+#ifdef LANG
+
+static const UInt32 kLangIDs[] =
+{
+  IDT_PROGRESS_ELAPSED,
+  IDT_PROGRESS_REMAINING,
+  IDT_PROGRESS_TOTAL,
+  IDT_PROGRESS_SPEED,
+  IDT_PROGRESS_PROCESSED,
+  IDT_PROGRESS_RATIO,
+  IDT_PROGRESS_ERRORS,
+  IDB_PROGRESS_BACKGROUND,
+  IDB_PAUSE
+};
+
+static const UInt32 kLangIDs_Colon[] =
+{
+  IDT_PROGRESS_PACKED,
+  IDT_PROGRESS_FILES
+};
+
+#endif
+
+
+#define UNDEFINED_VAL ((UInt64)(Int64)-1)
+#define INIT_AS_UNDEFINED(v) v = UNDEFINED_VAL;
+#define IS_UNDEFINED_VAL(v) ((v) == UNDEFINED_VAL)
+#define IS_DEFINED_VAL(v) ((v) != UNDEFINED_VAL)
+
+CProgressSync::CProgressSync():
+    _stopped(false), _paused(false),
+    _bytesProgressMode(true),
+    _totalBytes(UNDEFINED_VAL), _completedBytes(0),
+    _totalFiles(UNDEFINED_VAL), _curFiles(0),
+    _inSize(UNDEFINED_VAL),
+    _outSize(UNDEFINED_VAL),
+    _isDir(false)
+    {}
+
+#define CHECK_STOP  if (_stopped) return E_ABORT; if (!_paused) return S_OK;
+#define CRITICAL_LOCK NSynchronization::CCriticalSectionLock lock(_cs);
+
+bool CProgressSync::Get_Paused()
+{
+  CRITICAL_LOCK
+  return _paused;
+}
+
+HRESULT CProgressSync::CheckStop()
+{
+  for (;;)
+  {
+    {
+      CRITICAL_LOCK
+      CHECK_STOP
+    }
+    ::Sleep(kPauseSleepTime);
+  }
+}
+
+HRESULT CProgressSync::ScanProgress(UInt64 numFiles, UInt64 totalSize, const FString &fileName, bool isDir)
+{
+  {
+    CRITICAL_LOCK
+    _totalFiles = numFiles;
+    _totalBytes = totalSize;
+    _filePath = fs2us(fileName);
+    _isDir = isDir;
+    // _completedBytes = 0;
+    CHECK_STOP
+  }
+  return CheckStop();
+}
+
+HRESULT CProgressSync::Set_NumFilesTotal(UInt64 val)
+{
+  {
+    CRITICAL_LOCK
+    _totalFiles = val;
+    CHECK_STOP
+  }
+  return CheckStop();
+}
+
+void CProgressSync::Set_NumBytesTotal(UInt64 val)
+{
+  CRITICAL_LOCK
+  _totalBytes = val;
+}
+
+void CProgressSync::Set_NumFilesCur(UInt64 val)
+{
+  CRITICAL_LOCK
+  _curFiles = val;
+}
+
+HRESULT CProgressSync::Set_NumBytesCur(const UInt64 *val)
+{
+  {
+    CRITICAL_LOCK
+    if (val)
+      _completedBytes = *val;
+    CHECK_STOP
+  }
+  return CheckStop();
+}
+
+HRESULT CProgressSync::Set_NumBytesCur(UInt64 val)
+{
+  {
+    CRITICAL_LOCK
+    _completedBytes = val;
+    CHECK_STOP
+  }
+  return CheckStop();
+}
+
+void CProgressSync::Set_Ratio(const UInt64 *inSize, const UInt64 *outSize)
+{
+  CRITICAL_LOCK
+  if (inSize)
+    _inSize = *inSize;
+  if (outSize)
+    _outSize = *outSize;
+}
+
+void CProgressSync::Set_TitleFileName(const UString &fileName)
+{
+  CRITICAL_LOCK
+  _titleFileName = fileName;
+}
+
+void CProgressSync::Set_Status(const UString &s)
+{
+  CRITICAL_LOCK
+  _status = s;
+}
+
+HRESULT CProgressSync::Set_Status2(const UString &s, const wchar_t *path, bool isDir)
+{
+  {
+    CRITICAL_LOCK
+    _status = s;
+    if (path)
+      _filePath = path;
+    else
+      _filePath.Empty();
+    _isDir = isDir;
+  }
+  return CheckStop();
+}
+
+void CProgressSync::Set_FilePath(const wchar_t *path, bool isDir)
+{
+  CRITICAL_LOCK
+  if (path)
+    _filePath = path;
+  else
+    _filePath.Empty();
+  _isDir = isDir;
+}
+
+
+void CProgressSync::AddError_Message(const wchar_t *message)
+{
+  CRITICAL_LOCK
+  Messages.Add(message);
+}
+
+void CProgressSync::AddError_Message_Name(const wchar_t *message, const wchar_t *name)
+{
+  UString s;
+  if (name && *name != 0)
+    s += name;
+  if (message && *message != 0)
+  {
+    if (!s.IsEmpty())
+      s.Add_LF();
+    s += message;
+    if (!s.IsEmpty() && s.Back() == L'\n')
+      s.DeleteBack();
+  }
+  AddError_Message(s);
+}
+
+void CProgressSync::AddError_Code_Name(DWORD systemError, const wchar_t *name)
+{
+  UString s = NError::MyFormatMessage(systemError);
+  if (systemError == 0)
+    s = "Error";
+  AddError_Message_Name(s, name);
+}
+
+CProgressDialog::CProgressDialog():
+   _timer(0),
+   CompressingMode(true),
+   MainWindow(NULL)
+{
+  _isDir = false;
+
+  _numMessages = 0;
+  IconID = -1;
+  MessagesDisplayed = false;
+  _wasCreated = false;
+  _needClose = false;
+  _inCancelMessageBox = false;
+  _externalCloseMessageWasReceived = false;
+  
+  _numPostedMessages = 0;
+  _numAutoSizeMessages = 0;
+  _errorsWereDisplayed = false;
+  _waitCloseByCancelButton = false;
+  _cancelWasPressed = false;
+  ShowCompressionInfo = true;
+  WaitMode = false;
+  if (_dialogCreatedEvent.Create() != S_OK)
+    throw 1334987;
+  if (_createDialogEvent.Create() != S_OK)
+    throw 1334987;
+  #ifdef __ITaskbarList3_INTERFACE_DEFINED__
+  CoCreateInstance(CLSID_TaskbarList, NULL, CLSCTX_INPROC_SERVER, IID_ITaskbarList3, (void**)&_taskbarList);
+  if (_taskbarList)
+    _taskbarList->HrInit();
+  #endif
+}
+
+#ifndef _SFX
+
+CProgressDialog::~CProgressDialog()
+{
+  #ifdef __ITaskbarList3_INTERFACE_DEFINED__
+  SetTaskbarProgressState(TBPF_NOPROGRESS);
+  #endif
+  AddToTitle(L"");
+}
+void CProgressDialog::AddToTitle(LPCWSTR s)
+{
+  if (MainWindow)
+  {
+    CWindow window(MainWindow);
+    window.SetText((UString)s + MainTitle);
+  }
+}
+
+#endif
+
+
+void CProgressDialog::SetTaskbarProgressState()
+{
+  #ifdef __ITaskbarList3_INTERFACE_DEFINED__
+  if (_taskbarList && _hwndForTaskbar)
+  {
+    TBPFLAG tbpFlags;
+    if (Sync.Get_Paused())
+      tbpFlags = TBPF_PAUSED;
+    else
+      tbpFlags = _errorsWereDisplayed ? TBPF_ERROR: TBPF_NORMAL;
+    SetTaskbarProgressState(tbpFlags);
+  }
+  #endif
+}
+
+static const unsigned kTitleFileNameSizeLimit = 36;
+static const unsigned kCurrentFileNameSizeLimit = 82;
+
+static void ReduceString(UString &s, unsigned size)
+{
+  if (s.Len() <= size)
+    return;
+  s.Delete(size / 2, s.Len() - size);
+  s.Insert(size / 2, L" ... ");
+}
+
+void CProgressDialog::EnableErrorsControls(bool enable)
+{
+  ShowItem_Bool(IDT_PROGRESS_ERRORS, enable);
+  ShowItem_Bool(IDT_PROGRESS_ERRORS_VAL, enable);
+  ShowItem_Bool(IDL_PROGRESS_MESSAGES, enable);
+}
+
+bool CProgressDialog::OnInit()
+{
+  _hwndForTaskbar = MainWindow;
+  if (!_hwndForTaskbar)
+    _hwndForTaskbar = GetParent();
+  if (!_hwndForTaskbar)
+    _hwndForTaskbar = *this;
+
+  INIT_AS_UNDEFINED(_progressBar_Range);
+  INIT_AS_UNDEFINED(_progressBar_Pos);
+
+  INIT_AS_UNDEFINED(_prevPercentValue);
+  INIT_AS_UNDEFINED(_prevElapsedSec);
+  INIT_AS_UNDEFINED(_prevRemainingSec);
+
+  INIT_AS_UNDEFINED(_prevSpeed);
+  _prevSpeed_MoveBits = 0;
+  
+  _prevTime = ::GetTickCount();
+  _elapsedTime = 0;
+
+  INIT_AS_UNDEFINED(_totalBytes_Prev);
+  INIT_AS_UNDEFINED(_processed_Prev);
+  INIT_AS_UNDEFINED(_packed_Prev);
+  INIT_AS_UNDEFINED(_ratio_Prev);
+  
+  _filesStr_Prev.Empty();
+  _filesTotStr_Prev.Empty();
+
+  _foreground = true;
+
+  m_ProgressBar.Attach(GetItem(IDC_PROGRESS1));
+  _messageList.Attach(GetItem(IDL_PROGRESS_MESSAGES));
+  _messageList.SetUnicodeFormat();
+  _messageList.SetExtendedListViewStyle(LVS_EX_FULLROWSELECT);
+
+  _wasCreated = true;
+  _dialogCreatedEvent.Set();
+
+  #ifdef LANG
+  LangSetDlgItems(*this, kLangIDs, ARRAY_SIZE(kLangIDs));
+  LangSetDlgItems_Colon(*this, kLangIDs_Colon, ARRAY_SIZE(kLangIDs_Colon));
+  #endif
+
+  CWindow window(GetItem(IDB_PROGRESS_BACKGROUND));
+  window.GetText(_background_String);
+  _backgrounded_String = _background_String;
+  _backgrounded_String.RemoveChar(L'&');
+
+  window = GetItem(IDB_PAUSE);
+  window.GetText(_pause_String);
+
+  LangString(IDS_PROGRESS_FOREGROUND, _foreground_String);
+  LangString(IDS_CONTINUE, _continue_String);
+  LangString(IDS_PROGRESS_PAUSED, _paused_String);
+
+  SetText(_title);
+  SetPauseText();
+  SetPriorityText();
+
+  _messageList.InsertColumn(0, L"", 30);
+  _messageList.InsertColumn(1, L"", 600);
+
+  _messageList.SetColumnWidthAuto(0);
+  _messageList.SetColumnWidthAuto(1);
+
+  EnableErrorsControls(false);
+
+  GetItemSizes(IDCANCEL, _buttonSizeX, _buttonSizeY);
+  _numReduceSymbols = kCurrentFileNameSizeLimit;
+  NormalizeSize(true);
+
+  if (!ShowCompressionInfo)
+  {
+    HideItem(IDT_PROGRESS_PACKED);
+    HideItem(IDT_PROGRESS_PACKED_VAL);
+    HideItem(IDT_PROGRESS_RATIO);
+    HideItem(IDT_PROGRESS_RATIO_VAL);
+  }
+
+  if (IconID >= 0)
+  {
+    HICON icon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IconID));
+    // SetIcon(ICON_SMALL, icon);
+    SetIcon(ICON_BIG, icon);
+  }
+  _timer = SetTimer(kTimerID, kTimerElapse);
+  #ifdef UNDER_CE
+  Foreground();
+  #endif
+
+  CheckNeedClose();
+
+  SetTaskbarProgressState();
+
+  return CModalDialog::OnInit();
+}
+
+static const UINT kIDs[] =
+{
+  IDT_PROGRESS_ELAPSED,   IDT_PROGRESS_ELAPSED_VAL,
+  IDT_PROGRESS_REMAINING, IDT_PROGRESS_REMAINING_VAL,
+  IDT_PROGRESS_FILES,     IDT_PROGRESS_FILES_VAL,
+  0,                      IDT_PROGRESS_FILES_TOTAL,
+  IDT_PROGRESS_ERRORS,    IDT_PROGRESS_ERRORS_VAL,
+  
+  IDT_PROGRESS_TOTAL,     IDT_PROGRESS_TOTAL_VAL,
+  IDT_PROGRESS_SPEED,     IDT_PROGRESS_SPEED_VAL,
+  IDT_PROGRESS_PROCESSED, IDT_PROGRESS_PROCESSED_VAL,
+  IDT_PROGRESS_PACKED,    IDT_PROGRESS_PACKED_VAL,
+  IDT_PROGRESS_RATIO,     IDT_PROGRESS_RATIO_VAL
+};
+
+bool CProgressDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+  int sY;
+  int sStep;
+  int mx, my;
+  {
+    RECT r;
+    GetClientRectOfItem(IDT_PROGRESS_ELAPSED, r);
+    mx = r.left;
+    my = r.top;
+    sY = RECT_SIZE_Y(r);
+    GetClientRectOfItem(IDT_PROGRESS_REMAINING, r);
+    sStep = r.top - my;
+  }
+
+  InvalidateRect(NULL);
+
+  int xSizeClient = xSize - mx * 2;
+
+  {
+    int i;
+    for (i = 800; i > 40; i = i * 9 / 10)
+      if (Units_To_Pixels_X(i) <= xSizeClient)
+        break;
+    _numReduceSymbols = i / 4;
+  }
+
+  int yPos = ySize - my - _buttonSizeY;
+
+  ChangeSubWindowSizeX(GetItem(IDT_PROGRESS_STATUS), xSize - mx * 2);
+  ChangeSubWindowSizeX(GetItem(IDT_PROGRESS_FILE_NAME), xSize - mx * 2);
+  ChangeSubWindowSizeX(GetItem(IDC_PROGRESS1), xSize - mx * 2);
+
+  int bSizeX = _buttonSizeX;
+  int mx2 = mx;
+  for (;; mx2--)
+  {
+    int bSize2 = bSizeX * 3 + mx2 * 2;
+    if (bSize2 <= xSizeClient)
+      break;
+    if (mx2 < 5)
+    {
+      bSizeX = (xSizeClient - mx2 * 2) / 3;
+      break;
+    }
+  }
+  if (bSizeX < 2)
+    bSizeX = 2;
+
+  {
+    RECT r;
+    GetClientRectOfItem(IDL_PROGRESS_MESSAGES, r);
+    int y = r.top;
+    int ySize2 = yPos - my - y;
+    const int kMinYSize = _buttonSizeY + _buttonSizeY * 3 / 4;
+    int xx = xSize - mx * 2;
+    if (ySize2 < kMinYSize)
+    {
+      ySize2 = kMinYSize;
+      if (xx > bSizeX * 2)
+        xx -= bSizeX;
+    }
+
+    _messageList.Move(mx, y, xx, ySize2);
+  }
+
+  {
+    int xPos = xSize - mx;
+    xPos -= bSizeX;
+    MoveItem(IDCANCEL, xPos, yPos, bSizeX, _buttonSizeY);
+    xPos -= (mx2 + bSizeX);
+    MoveItem(IDB_PAUSE, xPos, yPos, bSizeX, _buttonSizeY);
+    xPos -= (mx2 + bSizeX);
+    MoveItem(IDB_PROGRESS_BACKGROUND, xPos, yPos, bSizeX, _buttonSizeY);
+  }
+
+  int valueSize;
+  int labelSize;
+  int padSize;
+
+  labelSize = Units_To_Pixels_X(MY_PROGRESS_LABEL_UNITS_MIN);
+  valueSize = Units_To_Pixels_X(MY_PROGRESS_VAL_UNITS);
+  padSize = Units_To_Pixels_X(MY_PROGRESS_PAD_UNITS);
+  int requiredSize = (labelSize + valueSize) * 2 + padSize;
+
+  int gSize;
+  {
+    if (requiredSize < xSizeClient)
+    {
+      int incr = (xSizeClient - requiredSize) / 3;
+      labelSize += incr;
+    }
+    else
+      labelSize = (xSizeClient - valueSize * 2 - padSize) / 2;
+    if (labelSize < 0)
+      labelSize = 0;
+
+    gSize = labelSize + valueSize;
+    padSize = xSizeClient - gSize * 2;
+  }
+
+  labelSize = gSize - valueSize;
+
+  yPos = my;
+  for (unsigned i = 0; i < ARRAY_SIZE(kIDs); i += 2)
+  {
+    int x = mx;
+    const unsigned kNumColumn1Items = 5 * 2;
+    if (i >= kNumColumn1Items)
+    {
+      if (i == kNumColumn1Items)
+        yPos = my;
+      x = mx + gSize + padSize;
+    }
+    if (kIDs[i] != 0)
+    MoveItem(kIDs[i], x, yPos, labelSize, sY);
+    MoveItem(kIDs[i + 1], x + labelSize, yPos, valueSize, sY);
+    yPos += sStep;
+  }
+  return false;
+}
+
+void CProgressDialog::OnCancel() { Sync.Set_Stopped(true); }
+void CProgressDialog::OnOK() { }
+
+void CProgressDialog::SetProgressRange(UInt64 range)
+{
+  if (range == _progressBar_Range)
+    return;
+  _progressBar_Range = range;
+  INIT_AS_UNDEFINED(_progressBar_Pos);
+  _progressConv.Init(range);
+  m_ProgressBar.SetRange32(0, _progressConv.Count(range));
+}
+
+void CProgressDialog::SetProgressPos(UInt64 pos)
+{
+  if (pos >= _progressBar_Range ||
+      pos <= _progressBar_Pos ||
+      pos - _progressBar_Pos >= (_progressBar_Range >> 10))
+  {
+    m_ProgressBar.SetPos(_progressConv.Count(pos));
+    #ifdef __ITaskbarList3_INTERFACE_DEFINED__
+    if (_taskbarList && _hwndForTaskbar)
+      _taskbarList->SetProgressValue(_hwndForTaskbar, pos, _progressBar_Range);
+    #endif
+    _progressBar_Pos = pos;
+  }
+}
+
+#define UINT_TO_STR_2(val) { s[0] = (wchar_t)('0' + (val) / 10); s[1] = (wchar_t)('0' + (val) % 10); s += 2; }
+
+void GetTimeString(UInt64 timeValue, wchar_t *s);
+void GetTimeString(UInt64 timeValue, wchar_t *s)
+{
+  UInt64 hours = timeValue / 3600;
+  UInt32 seconds = (UInt32)(timeValue - hours * 3600);
+  UInt32 minutes = seconds / 60;
+  seconds %= 60;
+  if (hours > 99)
+  {
+    ConvertUInt64ToString(hours, s);
+    for (; *s != 0; s++);
+  }
+  else
+  {
+    UInt32 hours32 = (UInt32)hours;
+    UINT_TO_STR_2(hours32);
+  }
+  *s++ = ':'; UINT_TO_STR_2(minutes);
+  *s++ = ':'; UINT_TO_STR_2(seconds);
+  *s = 0;
+}
+
+static void ConvertSizeToString(UInt64 v, wchar_t *s)
+{
+  Byte c = 0;
+       if (v >= ((UInt64)100000 << 20)) { v >>= 30; c = 'G'; }
+  else if (v >= ((UInt64)100000 << 10)) { v >>= 20; c = 'M'; }
+  else if (v >= ((UInt64)100000 <<  0)) { v >>= 10; c = 'K'; }
+  ConvertUInt64ToString(v, s);
+  if (c != 0)
+  {
+    s += MyStringLen(s);
+    *s++ = ' ';
+    *s++ = c;
+    *s++ = 'B';
+    *s++ = 0;
+  }
+}
+
+void CProgressDialog::ShowSize(int id, UInt64 val, UInt64 &prev)
+{
+  if (val == prev)
+    return;
+  prev = val;
+  wchar_t s[40];
+  s[0] = 0;
+  if (IS_DEFINED_VAL(val))
+    ConvertSizeToString(val, s);
+  SetItemText(id, s);
+}
+
+static void GetChangedString(const UString &newStr, UString &prevStr, bool &hasChanged)
+{
+  hasChanged = !(prevStr == newStr);
+  if (hasChanged)
+    prevStr = newStr;
+}
+
+static unsigned GetPower32(UInt32 val)
+{
+  const unsigned kStart = 32;
+  UInt32 mask = ((UInt32)1 << (kStart - 1));
+  for (unsigned i = kStart;; i--)
+  {
+    if (i == 0 || (val & mask) != 0)
+      return i;
+    mask >>= 1;
+  }
+}
+
+static unsigned GetPower64(UInt64 val)
+{
+  UInt32 high = (UInt32)(val >> 32);
+  if (high == 0)
+    return GetPower32((UInt32)val);
+  return GetPower32(high) + 32;
+}
+
+static UInt64 MyMultAndDiv(UInt64 mult1, UInt64 mult2, UInt64 divider)
+{
+  unsigned pow1 = GetPower64(mult1);
+  unsigned pow2 = GetPower64(mult2);
+  while (pow1 + pow2 > 64)
+  {
+    if (pow1 > pow2) { pow1--; mult1 >>= 1; }
+    else             { pow2--; mult2 >>= 1; }
+    divider >>= 1;
+  }
+  UInt64 res = mult1 * mult2;
+  if (divider != 0)
+    res /= divider;
+  return res;
+}
+
+void CProgressDialog::UpdateStatInfo(bool showAll)
+{
+  UInt64 total, completed, totalFiles, completedFiles, inSize, outSize;
+  bool bytesProgressMode;
+
+  bool titleFileName_Changed;
+  bool curFilePath_Changed;
+  bool status_Changed;
+  unsigned numErrors;
+  {
+    NSynchronization::CCriticalSectionLock lock(Sync._cs);
+    total = Sync._totalBytes;
+    completed = Sync._completedBytes;
+    totalFiles = Sync._totalFiles;
+    completedFiles = Sync._curFiles;
+    inSize = Sync._inSize;
+    outSize = Sync._outSize;
+    bytesProgressMode = Sync._bytesProgressMode;
+
+    GetChangedString(Sync._titleFileName, _titleFileName, titleFileName_Changed);
+    GetChangedString(Sync._filePath, _filePath, curFilePath_Changed);
+    GetChangedString(Sync._status, _status, status_Changed);
+    if (_isDir != Sync._isDir)
+    {
+      curFilePath_Changed = true;
+      _isDir = Sync._isDir;
+    }
+    numErrors = Sync.Messages.Size();
+  }
+
+  UInt32 curTime = ::GetTickCount();
+
+  const UInt64 progressTotal = bytesProgressMode ? total : totalFiles;
+  const UInt64 progressCompleted = bytesProgressMode ? completed : completedFiles;
+  {
+    if (IS_UNDEFINED_VAL(progressTotal))
+    {
+      // SetPos(0);
+      // SetRange(progressCompleted);
+    }
+    else
+    {
+      if (_progressBar_Pos != 0 || progressCompleted != 0 ||
+          (_progressBar_Range == 0 && progressTotal != 0))
+      {
+        SetProgressRange(progressTotal);
+        SetProgressPos(progressCompleted);
+      }
+    }
+  }
+
+  ShowSize(IDT_PROGRESS_TOTAL_VAL, total, _totalBytes_Prev);
+
+  _elapsedTime += (curTime - _prevTime);
+  _prevTime = curTime;
+  UInt64 elapsedSec = _elapsedTime / 1000;
+  bool elapsedChanged = false;
+  if (elapsedSec != _prevElapsedSec)
+  {
+    _prevElapsedSec = elapsedSec;
+    elapsedChanged = true;
+    wchar_t s[40];
+    GetTimeString(elapsedSec, s);
+    SetItemText(IDT_PROGRESS_ELAPSED_VAL, s);
+  }
+
+  bool needSetTitle = false;
+  if (elapsedChanged || showAll)
+  {
+    if (numErrors > _numPostedMessages)
+    {
+      UpdateMessagesDialog();
+      wchar_t s[32];
+      ConvertUInt64ToString(numErrors, s);
+      SetItemText(IDT_PROGRESS_ERRORS_VAL, s);
+      if (!_errorsWereDisplayed)
+      {
+        _errorsWereDisplayed = true;
+        EnableErrorsControls(true);
+        SetTaskbarProgressState();
+      }
+    }
+
+    if (progressCompleted != 0)
+    {
+      if (IS_UNDEFINED_VAL(progressTotal))
+      {
+        if (IS_DEFINED_VAL(_prevRemainingSec))
+        {
+          INIT_AS_UNDEFINED(_prevRemainingSec);
+          SetItemText(IDT_PROGRESS_REMAINING_VAL, L"");
+        }
+      }
+      else
+      {
+        UInt64 remainingTime = 0;
+        if (progressCompleted < progressTotal)
+          remainingTime = MyMultAndDiv(_elapsedTime, progressTotal - progressCompleted, progressCompleted);
+        UInt64 remainingSec = remainingTime / 1000;
+        if (remainingSec != _prevRemainingSec)
+        {
+          _prevRemainingSec = remainingSec;
+          wchar_t s[40];
+          GetTimeString(remainingSec, s);
+          SetItemText(IDT_PROGRESS_REMAINING_VAL, s);
+        }
+      }
+      {
+        UInt64 elapsedTime = (_elapsedTime == 0) ? 1 : _elapsedTime;
+        UInt64 v = (progressCompleted * 1000) / elapsedTime;
+        Byte c = 0;
+        unsigned moveBits = 0;
+             if (v >= ((UInt64)10000 << 10)) { moveBits = 20; c = 'M'; }
+        else if (v >= ((UInt64)10000 <<  0)) { moveBits = 10; c = 'K'; }
+        v >>= moveBits;
+        if (moveBits != _prevSpeed_MoveBits || v != _prevSpeed)
+        {
+          _prevSpeed_MoveBits = moveBits;
+          _prevSpeed = v;
+          wchar_t s[40];
+          ConvertUInt64ToString(v, s);
+          unsigned pos = MyStringLen(s);
+          s[pos++] = ' ';
+          if (moveBits != 0)
+            s[pos++] = c;
+          s[pos++] = 'B';
+          s[pos++] = '/';
+          s[pos++] = 's';
+          s[pos++] = 0;
+          SetItemText(IDT_PROGRESS_SPEED_VAL, s);
+        }
+      }
+    }
+
+    {
+      UInt64 percent = 0;
+      {
+        if (IS_DEFINED_VAL(progressTotal))
+        {
+          percent = progressCompleted * 100;
+          if (progressTotal != 0)
+            percent /= progressTotal;
+        }
+      }
+      if (percent != _prevPercentValue)
+      {
+        _prevPercentValue = percent;
+        needSetTitle = true;
+      }
+    }
+    
+    {
+      wchar_t s[64];
+      
+      ConvertUInt64ToString(completedFiles, s);
+      if (_filesStr_Prev != s)
+      {
+        _filesStr_Prev = s;
+        SetItemText(IDT_PROGRESS_FILES_VAL, s);
+      }
+      
+      s[0] = 0;
+      if (IS_DEFINED_VAL(totalFiles))
+      {
+        MyStringCopy(s, L" / ");
+        ConvertUInt64ToString(totalFiles, s + MyStringLen(s));
+      }
+      if (_filesTotStr_Prev != s)
+      {
+        _filesTotStr_Prev = s;
+        SetItemText(IDT_PROGRESS_FILES_TOTAL, s);
+      }
+    }
+    
+    const UInt64 packSize   = CompressingMode ? outSize : inSize;
+    const UInt64 unpackSize = CompressingMode ? inSize : outSize;
+
+    if (IS_UNDEFINED_VAL(unpackSize) &&
+        IS_UNDEFINED_VAL(packSize))
+    {
+      ShowSize(IDT_PROGRESS_PROCESSED_VAL, completed, _processed_Prev);
+      ShowSize(IDT_PROGRESS_PACKED_VAL, UNDEFINED_VAL, _packed_Prev);
+    }
+    else
+    {
+      ShowSize(IDT_PROGRESS_PROCESSED_VAL, unpackSize, _processed_Prev);
+      ShowSize(IDT_PROGRESS_PACKED_VAL, packSize, _packed_Prev);
+      
+      if (IS_DEFINED_VAL(packSize) &&
+          IS_DEFINED_VAL(unpackSize) &&
+          unpackSize != 0)
+      {
+        wchar_t s[32];
+        UInt64 ratio = packSize * 100 / unpackSize;
+        if (_ratio_Prev != ratio)
+        {
+          _ratio_Prev = ratio;
+          ConvertUInt64ToString(ratio, s);
+          MyStringCat(s, L"%");
+          SetItemText(IDT_PROGRESS_RATIO_VAL, s);
+        }
+      }
+    }
+  }
+
+  if (needSetTitle || titleFileName_Changed)
+    SetTitleText();
+
+  if (status_Changed)
+  {
+    UString s = _status;
+    ReduceString(s, _numReduceSymbols);
+    SetItemText(IDT_PROGRESS_STATUS, _status);
+  }
+
+  if (curFilePath_Changed)
+  {
+    UString s1, s2;
+    if (_isDir)
+      s1 = _filePath;
+    else
+    {
+      int slashPos = _filePath.ReverseFind_PathSepar();
+      if (slashPos >= 0)
+      {
+        s1.SetFrom(_filePath, (unsigned)(slashPos + 1));
+        s2 = _filePath.Ptr((unsigned)(slashPos + 1));
+      }
+      else
+        s2 = _filePath;
+    }
+    ReduceString(s1, _numReduceSymbols);
+    ReduceString(s2, _numReduceSymbols);
+    s1.Add_LF();
+    s1 += s2;
+    SetItemText(IDT_PROGRESS_FILE_NAME, s1);
+  }
+}
+
+bool CProgressDialog::OnTimer(WPARAM /* timerID */, LPARAM /* callback */)
+{
+  if (Sync.Get_Paused())
+    return true;
+  CheckNeedClose();
+  UpdateStatInfo(false);
+  return true;
+}
+
+struct CWaitCursor
+{
+  HCURSOR _waitCursor;
+  HCURSOR _oldCursor;
+  CWaitCursor()
+  {
+    _waitCursor = LoadCursor(NULL, IDC_WAIT);
+    if (_waitCursor != NULL)
+      _oldCursor = SetCursor(_waitCursor);
+  }
+  ~CWaitCursor()
+  {
+    if (_waitCursor != NULL)
+      SetCursor(_oldCursor);
+  }
+};
+
+INT_PTR CProgressDialog::Create(const UString &title, NWindows::CThread &thread, HWND wndParent)
+{
+  INT_PTR res = 0;
+  try
+  {
+    if (WaitMode)
+    {
+      CWaitCursor waitCursor;
+      HANDLE h[] = { thread, _createDialogEvent };
+      
+      DWORD res2 = WaitForMultipleObjects(ARRAY_SIZE(h), h, FALSE, kCreateDelay);
+      if (res2 == WAIT_OBJECT_0 && !Sync.ThereIsMessage())
+        return 0;
+    }
+    _title = title;
+    BIG_DIALOG_SIZE(360, 192);
+    res = CModalDialog::Create(SIZED_DIALOG(IDD_PROGRESS), wndParent);
+  }
+  catch(...)
+  {
+    _wasCreated = true;
+    _dialogCreatedEvent.Set();
+  }
+  thread.Wait_Close();
+  if (!MessagesDisplayed)
+    MessageBoxW(wndParent, L"Progress Error", L"7-Zip", MB_ICONERROR);
+  return res;
+}
+
+bool CProgressDialog::OnExternalCloseMessage()
+{
+  // it doesn't work if there is MessageBox.
+  #ifdef __ITaskbarList3_INTERFACE_DEFINED__
+  SetTaskbarProgressState(TBPF_NOPROGRESS);
+  #endif
+  // AddToTitle(L"Finished ");
+  // SetText(L"Finished2 ");
+
+  UpdateStatInfo(true);
+  
+  SetItemText(IDCANCEL, LangString(IDS_CLOSE));
+  ::SendMessage(GetItem(IDCANCEL), BM_SETSTYLE, BS_DEFPUSHBUTTON, MAKELPARAM(TRUE, 0));
+  HideItem(IDB_PROGRESS_BACKGROUND);
+  HideItem(IDB_PAUSE);
+
+  ProcessWasFinished_GuiVirt();
+
+  bool thereAreMessages;
+  CProgressFinalMessage fm;
+  {
+    NSynchronization::CCriticalSectionLock lock(Sync._cs);
+    thereAreMessages = !Sync.Messages.IsEmpty();
+    fm = Sync.FinalMessage;
+  }
+
+  if (!fm.ErrorMessage.Message.IsEmpty())
+  {
+    MessagesDisplayed = true;
+    if (fm.ErrorMessage.Title.IsEmpty())
+      fm.ErrorMessage.Title = "7-Zip";
+    MessageBoxW(*this, fm.ErrorMessage.Message, fm.ErrorMessage.Title, MB_ICONERROR);
+  }
+  else if (!thereAreMessages)
+  {
+    MessagesDisplayed = true;
+
+    if (!fm.OkMessage.Message.IsEmpty())
+    {
+      if (fm.OkMessage.Title.IsEmpty())
+        fm.OkMessage.Title = "7-Zip";
+      MessageBoxW(*this, fm.OkMessage.Message, fm.OkMessage.Title, MB_OK);
+    }
+  }
+
+  if (thereAreMessages && !_cancelWasPressed)
+  {
+    _waitCloseByCancelButton = true;
+    UpdateMessagesDialog();
+    return true;
+  }
+
+  End(0);
+  return true;
+}
+
+bool CProgressDialog::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+  switch (message)
+  {
+    case kCloseMessage:
+    {
+      if (_timer)
+      {
+        /* 21.03 : KillTimer(kTimerID) instead of KillTimer(_timer).
+           But (_timer == kTimerID) in Win10. So it worked too */
+        KillTimer(kTimerID);
+        _timer = 0;
+      }
+      if (_inCancelMessageBox)
+      {
+        /* if user is in MessageBox(), we will call OnExternalCloseMessage()
+           later, when MessageBox() will be closed */
+        _externalCloseMessageWasReceived = true;
+        break;
+      }
+      return OnExternalCloseMessage();
+    }
+    /*
+    case WM_SETTEXT:
+    {
+      if (_timer == 0)
+        return true;
+      break;
+    }
+    */
+  }
+  return CModalDialog::OnMessage(message, wParam, lParam);
+}
+
+void CProgressDialog::SetTitleText()
+{
+  UString s;
+  if (Sync.Get_Paused())
+  {
+    s += _paused_String;
+    s.Add_Space();
+  }
+  if (IS_DEFINED_VAL(_prevPercentValue))
+  {
+    char temp[32];
+    ConvertUInt64ToString(_prevPercentValue, temp);
+    s += temp;
+    s += '%';
+  }
+  if (!_foreground)
+  {
+    s.Add_Space();
+    s += _backgrounded_String;
+  }
+
+  s.Add_Space();
+  #ifndef _SFX
+  {
+    unsigned len = s.Len();
+    s += MainAddTitle;
+    AddToTitle(s);
+    s.DeleteFrom(len);
+  }
+  #endif
+
+  s += _title;
+  if (!_titleFileName.IsEmpty())
+  {
+    UString fileName = _titleFileName;
+    ReduceString(fileName, kTitleFileNameSizeLimit);
+    s.Add_Space();
+    s += fileName;
+  }
+  SetText(s);
+}
+
+void CProgressDialog::SetPauseText()
+{
+  SetItemText(IDB_PAUSE, Sync.Get_Paused() ? _continue_String : _pause_String);
+  SetTitleText();
+}
+
+void CProgressDialog::OnPauseButton()
+{
+  bool paused = !Sync.Get_Paused();
+  Sync.Set_Paused(paused);
+  UInt32 curTime = ::GetTickCount();
+  if (paused)
+    _elapsedTime += (curTime - _prevTime);
+  SetTaskbarProgressState();
+  _prevTime = curTime;
+  SetPauseText();
+}
+
+void CProgressDialog::SetPriorityText()
+{
+  SetItemText(IDB_PROGRESS_BACKGROUND, _foreground ?
+      _background_String :
+      _foreground_String);
+  SetTitleText();
+}
+
+void CProgressDialog::OnPriorityButton()
+{
+  _foreground = !_foreground;
+  #ifndef UNDER_CE
+  SetPriorityClass(GetCurrentProcess(), _foreground ? NORMAL_PRIORITY_CLASS: IDLE_PRIORITY_CLASS);
+  #endif
+  SetPriorityText();
+}
+
+void CProgressDialog::AddMessageDirect(LPCWSTR message, bool needNumber)
+{
+  wchar_t sz[16];
+  sz[0] = 0;
+  if (needNumber)
+    ConvertUInt32ToString(_numMessages + 1, sz);
+  const unsigned itemIndex = _messageStrings.Size(); // _messageList.GetItemCount();
+  if (_messageList.InsertItem((int)itemIndex, sz) == (int)itemIndex)
+  {
+    _messageList.SetSubItem((int)itemIndex, 1, message);
+    _messageStrings.Add(message);
+  }
+}
+
+void CProgressDialog::AddMessage(LPCWSTR message)
+{
+  UString s = message;
+  bool needNumber = true;
+  while (!s.IsEmpty())
+  {
+    int pos = s.Find(L'\n');
+    if (pos < 0)
+      break;
+    AddMessageDirect(s.Left(pos), needNumber);
+    needNumber = false;
+    s.DeleteFrontal(pos + 1);
+  }
+  AddMessageDirect(s, needNumber);
+  _numMessages++;
+}
+
+static unsigned GetNumDigits(UInt32 val)
+{
+  unsigned i;
+  for (i = 0; val >= 10; i++)
+    val /= 10;
+  return i;
+}
+
+void CProgressDialog::UpdateMessagesDialog()
+{
+  UStringVector messages;
+  {
+    NSynchronization::CCriticalSectionLock lock(Sync._cs);
+    unsigned num = Sync.Messages.Size();
+    if (num > _numPostedMessages)
+    {
+      messages.ClearAndReserve(num - _numPostedMessages);
+      for (unsigned i = _numPostedMessages; i < num; i++)
+        messages.AddInReserved(Sync.Messages[i]);
+      _numPostedMessages = num;
+    }
+  }
+  if (!messages.IsEmpty())
+  {
+    FOR_VECTOR (i, messages)
+      AddMessage(messages[i]);
+    if (_numAutoSizeMessages < 256 || GetNumDigits(_numPostedMessages) > GetNumDigits(_numAutoSizeMessages))
+    {
+      _messageList.SetColumnWidthAuto(0);
+      _messageList.SetColumnWidthAuto(1);
+      _numAutoSizeMessages = _numPostedMessages;
+    }
+  }
+}
+
+
+bool CProgressDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
+{
+  switch (buttonID)
+  {
+    // case IDOK: // if IDCANCEL is not DEFPUSHBUTTON
+    case IDCANCEL:
+    {
+      if (_waitCloseByCancelButton)
+      {
+        MessagesDisplayed = true;
+        End(IDCLOSE);
+        break;
+      }
+      
+      if (_cancelWasPressed)
+        return true;
+        
+      const bool paused = Sync.Get_Paused();
+      
+      if (!paused)
+      {
+        OnPauseButton();
+      }
+
+      _inCancelMessageBox = true;
+      const int res = ::MessageBoxW(*this, LangString(IDS_PROGRESS_ASK_CANCEL), _title, MB_YESNOCANCEL);
+      _inCancelMessageBox = false;
+      if (res == IDYES)
+        _cancelWasPressed = true;
+      
+      if (!paused)
+      {
+        OnPauseButton();
+      }
+
+      if (_externalCloseMessageWasReceived)
+      {
+        /* we have received kCloseMessage while we were in MessageBoxW().
+           so we call OnExternalCloseMessage() here.
+           it can show MessageBox and it can close dialog */
+        OnExternalCloseMessage();
+        return true;
+      }
+
+      if (!_cancelWasPressed)
+        return true;
+
+      MessagesDisplayed = true;
+      // we will call Sync.Set_Stopped(true) in OnButtonClicked() : OnCancel()
+      break;
+    }
+
+    case IDB_PAUSE:
+      OnPauseButton();
+      return true;
+    case IDB_PROGRESS_BACKGROUND:
+      OnPriorityButton();
+      return true;
+  }
+  return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+}
+
+void CProgressDialog::CheckNeedClose()
+{
+  if (_needClose)
+  {
+    PostMsg(kCloseMessage);
+    _needClose = false;
+  }
+}
+
+void CProgressDialog::ProcessWasFinished()
+{
+  // Set Window title here.
+  if (!WaitMode)
+    WaitCreating();
+  
+  if (_wasCreated)
+    PostMsg(kCloseMessage);
+  else
+    _needClose = true;
+}
+
+
+bool CProgressDialog::OnNotify(UINT /* controlID */, LPNMHDR header)
+{
+  if (header->hwndFrom != _messageList)
+    return false;
+  switch (header->code)
+  {
+    case LVN_KEYDOWN:
+    {
+      LPNMLVKEYDOWN keyDownInfo = LPNMLVKEYDOWN(header);
+      switch (keyDownInfo->wVKey)
+      {
+        case 'A':
+        {
+          if (IsKeyDown(VK_CONTROL))
+          {
+            _messageList.SelectAll();
+            return true;
+          }
+          break;
+        }
+        case VK_INSERT:
+        case 'C':
+        {
+          if (IsKeyDown(VK_CONTROL))
+          {
+            CopyToClipboard();
+            return true;
+          }
+          break;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+
+static void ListView_GetSelected(NControl::CListView &listView, CUIntVector &vector)
+{
+  vector.Clear();
+  int index = -1;
+  for (;;)
+  {
+    index = listView.GetNextSelectedItem(index);
+    if (index < 0)
+      break;
+    vector.Add(index);
+  }
+}
+
+
+void CProgressDialog::CopyToClipboard()
+{
+  CUIntVector indexes;
+  ListView_GetSelected(_messageList, indexes);
+  UString s;
+  unsigned numIndexes = indexes.Size();
+  if (numIndexes == 0)
+    numIndexes = _messageList.GetItemCount();
+  
+  for (unsigned i = 0; i < numIndexes; i++)
+  {
+    const unsigned index = (i < indexes.Size() ? indexes[i] : i);
+    // s.Add_UInt32(index);
+    // s += ": ";
+    s += _messageStrings[index];
+    {
+      s +=
+        #ifdef _WIN32
+          "\r\n"
+        #else
+          "\n"
+        #endif
+        ;
+    }
+  }
+  
+  ClipboardSetText(*this, s);
+}
+
+
+static THREAD_FUNC_DECL MyThreadFunction(void *param)
+{
+  CProgressThreadVirt *p = (CProgressThreadVirt *)param;
+  try
+  {
+    p->Process();
+    p->ThreadFinishedOK = true;
+  }
+  catch (...) { p->Result = E_FAIL; }
+  return 0;
+}
+
+
+HRESULT CProgressThreadVirt::Create(const UString &title, HWND parentWindow)
+{
+  NWindows::CThread thread;
+  RINOK(thread.Create(MyThreadFunction, this));
+  CProgressDialog::Create(title, thread, parentWindow);
+  return S_OK;
+}
+
+static void AddMessageToString(UString &dest, const UString &src)
+{
+  if (!src.IsEmpty())
+  {
+    if (!dest.IsEmpty())
+      dest.Add_LF();
+    dest += src;
+  }
+}
+
+void CProgressThreadVirt::Process()
+{
+  CProgressCloser closer(*this);
+  UString m;
+  try { Result = ProcessVirt(); }
+  catch(const wchar_t *s) { m = s; }
+  catch(const UString &s) { m = s; }
+  catch(const char *s) { m = GetUnicodeString(s); }
+  catch(int v)
+  {
+    m = "Error #";
+    m.Add_UInt32(v);
+  }
+  catch(...) { m = "Error"; }
+  if (Result != E_ABORT)
+  {
+    if (m.IsEmpty() && Result != S_OK)
+      m = HResultToMessage(Result);
+  }
+  AddMessageToString(m, FinalMessage.ErrorMessage.Message);
+
+  {
+    FOR_VECTOR(i, ErrorPaths)
+    {
+      if (i >= 32)
+        break;
+      AddMessageToString(m, fs2us(ErrorPaths[i]));
+    }
+  }
+
+  CProgressSync &sync = Sync;
+  NSynchronization::CCriticalSectionLock lock(sync._cs);
+  if (m.IsEmpty())
+  {
+    if (!FinalMessage.OkMessage.Message.IsEmpty())
+      sync.FinalMessage.OkMessage = FinalMessage.OkMessage;
+  }
+  else
+  {
+    sync.FinalMessage.ErrorMessage.Message = m;
+    if (Result == S_OK)
+      Result = E_FAIL;
+  }
+}
+
+UString HResultToMessage(HRESULT errorCode)
+{
+  if (errorCode == E_OUTOFMEMORY)
+    return LangString(IDS_MEM_ERROR);
+  else
+    return NError::MyFormatMessage(errorCode);
+}
diff --git a/CPP/7zip/UI/FileManager/ProgressDialog2.h b/CPP/7zip/UI/FileManager/ProgressDialog2.h
new file mode 100644
index 0000000..d8259d6
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ProgressDialog2.h
@@ -0,0 +1,357 @@
+// ProgressDialog2.h
+
+#ifndef __PROGRESS_DIALOG_2_H
+#define __PROGRESS_DIALOG_2_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/Synchronization.h"
+#include "../../../Windows/Thread.h"
+
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/ListView.h"
+#include "../../../Windows/Control/ProgressBar.h"
+
+#include "MyWindowsNew.h"
+
+struct CProgressMessageBoxPair
+{
+  UString Title;
+  UString Message;
+};
+
+struct CProgressFinalMessage
+{
+  CProgressMessageBoxPair ErrorMessage;
+  CProgressMessageBoxPair OkMessage;
+
+  bool ThereIsMessage() const { return !ErrorMessage.Message.IsEmpty() || !OkMessage.Message.IsEmpty(); }
+};
+
+class CProgressSync
+{
+  bool _stopped;
+  bool _paused;
+
+public:
+  bool _bytesProgressMode;
+  UInt64 _totalBytes;
+  UInt64 _completedBytes;
+  UInt64 _totalFiles;
+  UInt64 _curFiles;
+  UInt64 _inSize;
+  UInt64 _outSize;
+  
+  UString _titleFileName;
+  UString _status;
+  UString _filePath;
+  bool _isDir;
+
+  UStringVector Messages;
+  CProgressFinalMessage FinalMessage;
+
+  NWindows::NSynchronization::CCriticalSection _cs;
+
+  CProgressSync();
+
+  bool Get_Stopped()
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+    return _stopped;
+  }
+  void Set_Stopped(bool val)
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+    _stopped = val;
+  }
+  
+  bool Get_Paused();
+  void Set_Paused(bool val)
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+    _paused = val;
+  }
+  
+  void Set_BytesProgressMode(bool bytesProgressMode)
+  {
+    NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+    _bytesProgressMode = bytesProgressMode;
+  }
+  
+  HRESULT CheckStop();
+  HRESULT ScanProgress(UInt64 numFiles, UInt64 totalSize, const FString &fileName, bool isDir = false);
+
+  HRESULT Set_NumFilesTotal(UInt64 val);
+  void Set_NumBytesTotal(UInt64 val);
+  void Set_NumFilesCur(UInt64 val);
+  HRESULT Set_NumBytesCur(const UInt64 *val);
+  HRESULT Set_NumBytesCur(UInt64 val);
+  void Set_Ratio(const UInt64 *inSize, const UInt64 *outSize);
+
+  void Set_TitleFileName(const UString &fileName);
+  void Set_Status(const UString &s);
+  HRESULT Set_Status2(const UString &s, const wchar_t *path, bool isDir = false);
+  void Set_FilePath(const wchar_t *path, bool isDir = false);
+
+  void AddError_Message(const wchar_t *message);
+  void AddError_Message_Name(const wchar_t *message, const wchar_t *name);
+  void AddError_Code_Name(DWORD systemError, const wchar_t *name);
+
+  bool ThereIsMessage() const { return !Messages.IsEmpty() || FinalMessage.ThereIsMessage(); }
+};
+
+class CProgressDialog: public NWindows::NControl::CModalDialog
+{
+  UString _titleFileName;
+  UString _filePath;
+  UString _status;
+  bool _isDir;
+
+  UString _background_String;
+  UString _backgrounded_String;
+  UString _foreground_String;
+  UString _pause_String;
+  UString _continue_String;
+  UString _paused_String;
+
+  int _buttonSizeX;
+  int _buttonSizeY;
+
+  UINT_PTR _timer;
+
+  UString _title;
+
+  class CU64ToI32Converter
+  {
+    unsigned _numShiftBits;
+    UInt64 _range;
+  public:
+    CU64ToI32Converter(): _numShiftBits(0), _range(1) {}
+    void Init(UInt64 range)
+    {
+      _range = range;
+      // Windows CE doesn't like big number for ProgressBar.
+      for (_numShiftBits = 0; range >= ((UInt32)1 << 15); _numShiftBits++)
+        range >>= 1;
+    }
+    int Count(UInt64 val)
+    {
+      int res = (int)(val >> _numShiftBits);
+      if (val == _range)
+        res++;
+      return res;
+    }
+  };
+  
+  CU64ToI32Converter _progressConv;
+  UInt64 _progressBar_Pos;
+  UInt64 _progressBar_Range;
+  
+  NWindows::NControl::CProgressBar m_ProgressBar;
+  NWindows::NControl::CListView _messageList;
+  
+  int _numMessages;
+  UStringVector _messageStrings;
+
+  #ifdef __ITaskbarList3_INTERFACE_DEFINED__
+  CMyComPtr<ITaskbarList3> _taskbarList;
+  #endif
+  HWND _hwndForTaskbar;
+
+  UInt32 _prevTime;
+  UInt64 _elapsedTime;
+
+  UInt64 _prevPercentValue;
+  UInt64 _prevElapsedSec;
+  UInt64 _prevRemainingSec;
+
+  UInt64 _totalBytes_Prev;
+  UInt64 _processed_Prev;
+  UInt64 _packed_Prev;
+  UInt64 _ratio_Prev;
+
+  UString _filesStr_Prev;
+  UString _filesTotStr_Prev;
+
+  unsigned _prevSpeed_MoveBits;
+  UInt64 _prevSpeed;
+
+  bool _foreground;
+
+  unsigned _numReduceSymbols;
+
+  bool _wasCreated;
+  bool _needClose;
+
+  unsigned _numPostedMessages;
+  UInt32 _numAutoSizeMessages;
+
+  bool _errorsWereDisplayed;
+
+  bool _waitCloseByCancelButton;
+  bool _cancelWasPressed;
+  
+  bool _inCancelMessageBox;
+  bool _externalCloseMessageWasReceived;
+
+
+  #ifdef __ITaskbarList3_INTERFACE_DEFINED__
+  void SetTaskbarProgressState(TBPFLAG tbpFlags)
+  {
+    if (_taskbarList && _hwndForTaskbar)
+      _taskbarList->SetProgressState(_hwndForTaskbar, tbpFlags);
+  }
+  #endif
+  void SetTaskbarProgressState();
+
+  void UpdateStatInfo(bool showAll);
+  bool OnTimer(WPARAM timerID, LPARAM callback);
+  void SetProgressRange(UInt64 range);
+  void SetProgressPos(UInt64 pos);
+  virtual bool OnInit();
+  virtual bool OnSize(WPARAM wParam, int xSize, int ySize);
+  virtual void OnCancel();
+  virtual void OnOK();
+  virtual bool OnNotify(UINT /* controlID */, LPNMHDR header);
+  void CopyToClipboard();
+
+  NWindows::NSynchronization::CManualResetEvent _createDialogEvent;
+  NWindows::NSynchronization::CManualResetEvent _dialogCreatedEvent;
+  #ifndef _SFX
+  void AddToTitle(LPCWSTR string);
+  #endif
+
+  void SetPauseText();
+  void SetPriorityText();
+  void OnPauseButton();
+  void OnPriorityButton();
+  bool OnButtonClicked(int buttonID, HWND buttonHWND);
+  bool OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
+
+  void SetTitleText();
+  void ShowSize(int id, UInt64 val, UInt64 &prev);
+
+  void UpdateMessagesDialog();
+
+  void AddMessageDirect(LPCWSTR message, bool needNumber);
+  void AddMessage(LPCWSTR message);
+
+  bool OnExternalCloseMessage();
+  void EnableErrorsControls(bool enable);
+
+  void ShowAfterMessages(HWND wndParent);
+
+  void CheckNeedClose();
+public:
+  CProgressSync Sync;
+  bool CompressingMode;
+  bool WaitMode;
+  bool ShowCompressionInfo;
+  bool MessagesDisplayed; // = true if user pressed OK on all messages or there are no messages.
+  int IconID;
+
+  HWND MainWindow;
+  #ifndef _SFX
+  UString MainTitle;
+  UString MainAddTitle;
+  ~CProgressDialog();
+  #endif
+
+  CProgressDialog();
+  void WaitCreating()
+  {
+    _createDialogEvent.Set();
+    _dialogCreatedEvent.Lock();
+  }
+
+  INT_PTR Create(const UString &title, NWindows::CThread &thread, HWND wndParent = 0);
+
+
+  /* how it works:
+     1) the working thread calls ProcessWasFinished()
+        that sends kCloseMessage message to CProgressDialog (GUI) thread
+     2) CProgressDialog (GUI) thread receives kCloseMessage message and
+        calls ProcessWasFinished_GuiVirt();
+        So we can implement ProcessWasFinished_GuiVirt() and show special
+        results window in GUI thread with CProgressDialog as parent window
+  */
+
+  void ProcessWasFinished();
+  virtual void ProcessWasFinished_GuiVirt() {}
+};
+
+
+class CProgressCloser
+{
+  CProgressDialog *_p;
+public:
+  CProgressCloser(CProgressDialog &p) : _p(&p) {}
+  ~CProgressCloser() { _p->ProcessWasFinished(); }
+};
+
+
+class CProgressThreadVirt: public CProgressDialog
+{
+protected:
+  FStringVector ErrorPaths;
+  CProgressFinalMessage FinalMessage;
+
+  // error if any of HRESULT, ErrorMessage, ErrorPath
+  virtual HRESULT ProcessVirt() = 0;
+public:
+  HRESULT Result;
+  bool ThreadFinishedOK; // if there is no fatal exception
+
+  void Process();
+  void AddErrorPath(const FString &path) { ErrorPaths.Add(path); }
+
+  HRESULT Create(const UString &title, HWND parentWindow = 0);
+  CProgressThreadVirt(): Result(E_FAIL), ThreadFinishedOK(false) {}
+
+  CProgressMessageBoxPair &GetMessagePair(bool isError) { return isError ? FinalMessage.ErrorMessage : FinalMessage.OkMessage; }
+};
+
+UString HResultToMessage(HRESULT errorCode);
+
+/*
+how it works:
+
+client code inherits CProgressThreadVirt and calls
+CProgressThreadVirt::Create()
+{
+  it creates new thread that calls CProgressThreadVirt::Process();
+  it creates modal progress dialog window with ProgressDialog.Create()
+}
+
+CProgressThreadVirt::Process()
+{
+  {
+    Result = ProcessVirt(); // virtual function that must implement real work
+  }
+  if (exceptions) or FinalMessage.ErrorMessage.Message
+  {
+    set message to ProgressDialog.Sync.FinalMessage.ErrorMessage.Message
+  }
+  else if (FinalMessage.OkMessage.Message)
+  {
+    set message to ProgressDialog.Sync.FinalMessage.OkMessage
+  }
+
+  PostMsg(kCloseMessage);
+}
+
+
+CProgressDialog::OnExternalCloseMessage()
+{
+  if (ProgressDialog.Sync.FinalMessage)
+  {
+    WorkWasFinishedVirt();
+    Show (ProgressDialog.Sync.FinalMessage)
+    MessagesDisplayed = true;
+  }
+}
+
+*/
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/ProgressDialog2.rc b/CPP/7zip/UI/FileManager/ProgressDialog2.rc
new file mode 100644
index 0000000..4d0e0c7
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ProgressDialog2.rc
@@ -0,0 +1,40 @@
+#include "ProgressDialog2Res.h"
+#include "../../GuiCommon.rc"
+
+#undef DIALOG_ID
+#define DIALOG_ID  IDD_PROGRESS
+#define xc 360
+#define k 11
+#define z1s 16
+
+#include "ProgressDialog2a.rc"
+
+#ifdef UNDER_CE
+
+#include "../../GuiCommon.rc"
+
+
+#undef DIALOG_ID
+#undef m
+#undef k
+#undef z1s
+
+#define DIALOG_ID  IDD_PROGRESS_2
+#define m 4
+#define k 8
+#define z1s 12
+
+#define xc 280
+
+#include "ProgressDialog2a.rc"
+
+#endif
+
+STRINGTABLE DISCARDABLE
+{
+  IDS_PROGRESS_PAUSED     "Paused"
+  IDS_PROGRESS_FOREGROUND "&Foreground"
+  IDS_CONTINUE            "&Continue"
+  IDS_PROGRESS_ASK_CANCEL "Are you sure you want to cancel?"
+  IDS_CLOSE "&Close"
+}
diff --git a/CPP/7zip/UI/FileManager/ProgressDialog2Res.h b/CPP/7zip/UI/FileManager/ProgressDialog2Res.h
new file mode 100644
index 0000000..736c717
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ProgressDialog2Res.h
@@ -0,0 +1,49 @@
+#define IDD_PROGRESS       97
+#define IDD_PROGRESS_2  10097
+
+#define IDS_CLOSE                  408
+#define IDS_CONTINUE               411
+
+#define IDB_PROGRESS_BACKGROUND    444
+#define IDS_PROGRESS_FOREGROUND    445
+#define IDB_PAUSE                  446
+#define IDS_PROGRESS_PAUSED        447
+#define IDS_PROGRESS_ASK_CANCEL    448
+
+#define IDT_PROGRESS_PACKED       1008
+#define IDT_PROGRESS_FILES        1032
+
+#define IDT_PROGRESS_ELAPSED      3900
+#define IDT_PROGRESS_REMAINING    3901
+#define IDT_PROGRESS_TOTAL        3902
+#define IDT_PROGRESS_SPEED        3903
+#define IDT_PROGRESS_PROCESSED    3904
+#define IDT_PROGRESS_RATIO        3905
+#define IDT_PROGRESS_ERRORS       3906
+
+#define IDC_PROGRESS1              100
+#define IDL_PROGRESS_MESSAGES      101
+#define IDT_PROGRESS_FILE_NAME     102
+#define IDT_PROGRESS_STATUS        103
+
+#define IDT_PROGRESS_PACKED_VAL    110
+#define IDT_PROGRESS_FILES_VAL     111
+#define IDT_PROGRESS_FILES_TOTAL   112
+
+#define IDT_PROGRESS_ELAPSED_VAL   120
+#define IDT_PROGRESS_REMAINING_VAL 121
+#define IDT_PROGRESS_TOTAL_VAL     122
+#define IDT_PROGRESS_SPEED_VAL     123
+#define IDT_PROGRESS_PROCESSED_VAL 124
+#define IDT_PROGRESS_RATIO_VAL     125
+#define IDT_PROGRESS_ERRORS_VAL    126
+
+
+#ifdef UNDER_CE
+#define MY_PROGRESS_VAL_UNITS  44
+#else
+#define MY_PROGRESS_VAL_UNITS  72
+#endif
+#define MY_PROGRESS_LABEL_UNITS_MIN   60
+#define MY_PROGRESS_LABEL_UNITS_START 90
+#define MY_PROGRESS_PAD_UNITS  4
diff --git a/CPP/7zip/UI/FileManager/ProgressDialog2a.rc b/CPP/7zip/UI/FileManager/ProgressDialog2a.rc
new file mode 100644
index 0000000..dc7d797
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ProgressDialog2a.rc
@@ -0,0 +1,85 @@
+#undef bxs
+#define bxs 80
+
+#define x0s MY_PROGRESS_LABEL_UNITS_START
+#define x1s MY_PROGRESS_VAL_UNITS
+#define x2s MY_PROGRESS_LABEL_UNITS_START
+#define x3s MY_PROGRESS_VAL_UNITS
+
+#define x1 (m + x0s)
+#define x3 (xs - m - x3s)
+#define x2 (x3 - x2s)
+
+#undef y0
+#undef y1
+#undef y2
+#undef y3
+#undef y4
+
+#undef z0
+#undef z1
+#undef z2
+#undef z3
+
+#define y0 m
+#define y1 (y0 + k)
+#define y2 (y1 + k)
+#define y3 (y2 + k)
+#define y4 (y3 + k)
+
+#define z3 (y4 + k + 1)
+
+#define z2 (z3 + k + 1)
+#define z2s 24
+
+#define z1 (z2 + z2s)
+
+#define z0 (z1 + z1s + m)
+#define z0s 48
+
+#define yc (z0 + z0s + bys)
+
+
+DIALOG_ID  DIALOG  0, 0, xs, ys  MY_MODAL_RESIZE_DIALOG_STYLE  MY_FONT
+CAPTION "Progress"
+{
+  DEFPUSHBUTTON  "&Background", IDB_PROGRESS_BACKGROUND, bx3, by, bxs, bys
+  PUSHBUTTON     "&Pause",      IDB_PAUSE,               bx2, by, bxs, bys
+  PUSHBUTTON     "Cancel",      IDCANCEL,                bx1, by, bxs, bys
+
+
+  LTEXT  "Elapsed time:",      IDT_PROGRESS_ELAPSED,   m, y0, x0s, 8
+  LTEXT  "Remaining time:",    IDT_PROGRESS_REMAINING, m, y1, x0s, 8
+  LTEXT  "Files:",             IDT_PROGRESS_FILES,     m, y2, x0s, 8
+
+  LTEXT  "Errors:",            IDT_PROGRESS_ERRORS,    m, y4, x0s, 8
+
+
+  LTEXT  "Total size:",        IDT_PROGRESS_TOTAL,    x2, y0, x2s, 8
+  LTEXT  "Speed:",             IDT_PROGRESS_SPEED,    x2, y1, x2s, 8
+  LTEXT  "Processed:",         IDT_PROGRESS_PROCESSED,x2, y2, x2s, 8
+  LTEXT  "Compressed size:"  , IDT_PROGRESS_PACKED,   x2, y3, x2s, 8
+  LTEXT  "Compression ratio:", IDT_PROGRESS_RATIO,    x2, y4, x2s, 8
+
+  
+  RTEXT  "",  IDT_PROGRESS_ELAPSED_VAL,   x1, y0, x1s, MY_TEXT_NOPREFIX
+  RTEXT  "",  IDT_PROGRESS_REMAINING_VAL, x1, y1, x1s, MY_TEXT_NOPREFIX
+  RTEXT  "",  IDT_PROGRESS_FILES_VAL,     x1, y2, x1s, MY_TEXT_NOPREFIX
+  RTEXT  "",  IDT_PROGRESS_FILES_TOTAL,   x1, y3, x1s, MY_TEXT_NOPREFIX
+  RTEXT  "",  IDT_PROGRESS_ERRORS_VAL,    x1, y4, x1s, MY_TEXT_NOPREFIX
+
+  RTEXT  "",  IDT_PROGRESS_TOTAL_VAL,     x3, y0, x3s, MY_TEXT_NOPREFIX
+  RTEXT  "",  IDT_PROGRESS_SPEED_VAL,     x3, y1, x3s, MY_TEXT_NOPREFIX
+  RTEXT  "",  IDT_PROGRESS_PROCESSED_VAL, x3, y2, x3s, MY_TEXT_NOPREFIX
+  RTEXT  "",  IDT_PROGRESS_PACKED_VAL,    x3, y3, x3s, MY_TEXT_NOPREFIX
+  RTEXT  "",  IDT_PROGRESS_RATIO_VAL,     x3, y4, x3s, MY_TEXT_NOPREFIX
+
+  LTEXT  "", IDT_PROGRESS_STATUS, m, z3, xc, MY_TEXT_NOPREFIX
+  CONTROL  "", IDT_PROGRESS_FILE_NAME, "Static", SS_NOPREFIX | SS_LEFTNOWORDWRAP, m, z2, xc, z2s
+  
+  CONTROL  "Progress1", IDC_PROGRESS1, "msctls_progress32", PBS_SMOOTH | WS_BORDER, m, z1, xc, z1s
+
+  CONTROL  "List1", IDL_PROGRESS_MESSAGES, "SysListView32",
+           LVS_REPORT | LVS_SHOWSELALWAYS | LVS_NOCOLUMNHEADER | LVS_NOSORTHEADER | WS_BORDER | WS_TABSTOP,
+           m, z0, xc, z0s
+}
diff --git a/CPP/7zip/UI/FileManager/ProgressDialogRes.h b/CPP/7zip/UI/FileManager/ProgressDialogRes.h
new file mode 100644
index 0000000..cbf3beb
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ProgressDialogRes.h
@@ -0,0 +1,3 @@
+#define IDD_PROGRESS  97
+
+#define IDC_PROGRESS1  100
diff --git a/CPP/7zip/UI/FileManager/PropertyName.cpp b/CPP/7zip/UI/FileManager/PropertyName.cpp
new file mode 100644
index 0000000..838b6e3
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PropertyName.cpp
@@ -0,0 +1,23 @@
+// PropertyName.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+
+#include "LangUtils.h"
+#include "PropertyName.h"
+
+UString GetNameOfProperty(PROPID propID, const wchar_t *name)
+{
+  if (propID < 1000)
+  {
+    UString s = LangString(1000 + propID);
+    if (!s.IsEmpty())
+      return s;
+  }
+  if (name)
+    return name;
+  wchar_t temp[16];
+  ConvertUInt32ToString(propID, temp);
+  return temp;
+}
diff --git a/CPP/7zip/UI/FileManager/PropertyName.h b/CPP/7zip/UI/FileManager/PropertyName.h
new file mode 100644
index 0000000..4f0d6dc
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PropertyName.h
@@ -0,0 +1,10 @@
+// PropertyName.h
+
+#ifndef __PROPERTY_NAME_H
+#define __PROPERTY_NAME_H
+
+#include "../../../Common/MyString.h"
+
+UString GetNameOfProperty(PROPID propID, const wchar_t *name);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/PropertyName.rc b/CPP/7zip/UI/FileManager/PropertyName.rc
new file mode 100644
index 0000000..5de5aee
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PropertyName.rc
@@ -0,0 +1,100 @@
+#include "PropertyNameRes.h"
+
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+
+STRINGTABLE
+BEGIN
+  IDS_PROP_PATH         "Path"
+  IDS_PROP_NAME         "Name"
+  IDS_PROP_EXTENSION    "Extension"
+  IDS_PROP_IS_FOLDER    "Folder"
+  IDS_PROP_SIZE         "Size"
+  IDS_PROP_PACKED_SIZE  "Packed Size"
+  IDS_PROP_ATTRIBUTES   "Attributes"
+  IDS_PROP_CTIME        "Created"
+  IDS_PROP_ATIME        "Accessed"
+  IDS_PROP_MTIME        "Modified"
+  IDS_PROP_SOLID        "Solid"
+  IDS_PROP_C0MMENTED    "Commented"
+  IDS_PROP_ENCRYPTED    "Encrypted"
+  IDS_PROP_SPLIT_BEFORE "Split Before"
+  IDS_PROP_SPLIT_AFTER  "Split After"
+  IDS_PROP_DICTIONARY_SIZE "Dictionary"
+  IDS_PROP_CRC          "CRC"
+  IDS_PROP_FILE_TYPE    "Type"
+  IDS_PROP_ANTI         "Anti"
+  IDS_PROP_METHOD       "Method"
+  IDS_PROP_HOST_OS      "Host OS"
+  IDS_PROP_FILE_SYSTEM  "File System"
+  IDS_PROP_USER         "User"
+  IDS_PROP_GROUP        "Group"
+  IDS_PROP_BLOCK        "Block"
+  IDS_PROP_COMMENT      "Comment"
+  IDS_PROP_POSITION     "Position"
+  IDS_PROP_PREFIX       "Path Prefix"
+  IDS_PROP_FOLDERS      "Folders"
+  IDS_PROP_FILES        "Files"
+  IDS_PROP_VERSION      "Version"
+  IDS_PROP_VOLUME       "Volume"
+  IDS_PROP_IS_VOLUME    "Multivolume"
+  IDS_PROP_OFFSET       "Offset"
+  IDS_PROP_LINKS        "Links"
+  IDS_PROP_NUM_BLOCKS   "Blocks"
+  IDS_PROP_NUM_VOLUMES  "Volumes"
+
+  IDS_PROP_BIT64        "64-bit"
+  IDS_PROP_BIG_ENDIAN   "Big-endian"
+  IDS_PROP_CPU          "CPU"
+  IDS_PROP_PHY_SIZE     "Physical Size"
+  IDS_PROP_HEADERS_SIZE "Headers Size"
+  IDS_PROP_CHECKSUM     "Checksum"
+  IDS_PROP_CHARACTS     "Characteristics"
+  IDS_PROP_VA           "Virtual Address"
+  IDS_PROP_ID           "ID"
+  IDS_PROP_SHORT_NAME   "Short Name"
+  IDS_PROP_CREATOR_APP  "Creator Application"
+  IDS_PROP_SECTOR_SIZE  "Sector Size"
+  IDS_PROP_POSIX_ATTRIB "Mode"
+  IDS_PROP_SYM_LINK     "Symbolic Link"
+  IDS_PROP_ERROR        "Error"
+  IDS_PROP_TOTAL_SIZE   "Total Size"
+  IDS_PROP_FREE_SPACE   "Free Space"
+  IDS_PROP_CLUSTER_SIZE "Cluster Size"
+  IDS_PROP_VOLUME_NAME  "Label"
+  IDS_PROP_LOCAL_NAME   "Local Name"
+  IDS_PROP_PROVIDER     "Provider"
+  IDS_PROP_NT_SECURITY  "NT Security"
+  IDS_PROP_ALT_STREAM   "Alternate Stream"
+  IDS_PROP_AUX          "Aux"
+  IDS_PROP_DELETED      "Deleted"
+  IDS_PROP_IS_TREE      "Is Tree"
+  IDS_PROP_SHA1         "SHA-1"
+  IDS_PROP_SHA256       "SHA-256"
+  IDS_PROP_ERROR_TYPE   "Error Type"
+  IDS_PROP_NUM_ERRORS   "Errors"
+  IDS_PROP_ERROR_FLAGS  "Errors"
+  IDS_PROP_WARNING_FLAGS "Warnings"
+  IDS_PROP_WARNING      "Warning"
+  IDS_PROP_NUM_STREAMS  "Streams"
+  IDS_PROP_NUM_ALT_STREAMS "Alternate Streams"
+  IDS_PROP_ALT_STREAMS_SIZE "Alternate Streams Size"
+  IDS_PROP_VIRTUAL_SIZE "Virtual Size"
+  IDS_PROP_UNPACK_SIZE  "Unpack Size"
+  IDS_PROP_TOTAL_PHY_SIZE "Total Physical Size"
+  IDS_PROP_VOLUME_INDEX "Volume Index"
+  IDS_PROP_SUBTYPE      "SubType"
+  IDS_PROP_SHORT_COMMENT "Short Comment"
+  IDS_PROP_CODE_PAGE    "Code Page"
+  IDS_PROP_IS_NOT_ARC_TYPE  "Is not archive type"
+  IDS_PROP_PHY_SIZE_CANT_BE_DETECTED "Physical Size can't be detected"
+  IDS_PROP_ZEROS_TAIL_IS_ALLOWED "Zeros Tail Is Allowed"
+  IDS_PROP_TAIL_SIZE "Tail Size"
+  IDS_PROP_EMB_STUB_SIZE "Embedded Stub Size"
+  IDS_PROP_NT_REPARSE   "Link"
+  IDS_PROP_HARD_LINK    "Hard Link"
+  IDS_PROP_INODE        "iNode"
+  IDS_PROP_STREAM_ID    "Stream ID"
+  IDS_PROP_READ_ONLY    "Read-only"
+  IDS_PROP_OUT_NAME     "Out Name"
+  IDS_PROP_COPY_LINK    "Copy Link"
+END
diff --git a/CPP/7zip/UI/FileManager/PropertyNameRes.h b/CPP/7zip/UI/FileManager/PropertyNameRes.h
new file mode 100644
index 0000000..67f3390
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PropertyNameRes.h
@@ -0,0 +1,95 @@
+
+
+#define IDS_PROP_PATH             1003
+#define IDS_PROP_NAME             1004
+#define IDS_PROP_EXTENSION        1005
+#define IDS_PROP_IS_FOLDER        1006
+#define IDS_PROP_SIZE             1007
+#define IDS_PROP_PACKED_SIZE      1008
+#define IDS_PROP_ATTRIBUTES       1009
+#define IDS_PROP_CTIME            1010
+#define IDS_PROP_ATIME            1011
+#define IDS_PROP_MTIME            1012
+#define IDS_PROP_SOLID            1013
+#define IDS_PROP_C0MMENTED        1014
+#define IDS_PROP_ENCRYPTED        1015
+#define IDS_PROP_SPLIT_BEFORE     1016
+#define IDS_PROP_SPLIT_AFTER      1017
+#define IDS_PROP_DICTIONARY_SIZE  1018
+#define IDS_PROP_CRC              1019
+#define IDS_PROP_FILE_TYPE        1020
+#define IDS_PROP_ANTI             1021
+#define IDS_PROP_METHOD           1022
+#define IDS_PROP_HOST_OS          1023
+#define IDS_PROP_FILE_SYSTEM      1024
+#define IDS_PROP_USER             1025
+#define IDS_PROP_GROUP            1026
+#define IDS_PROP_BLOCK            1027
+#define IDS_PROP_COMMENT          1028
+#define IDS_PROP_POSITION         1029
+#define IDS_PROP_PREFIX           1030
+#define IDS_PROP_FOLDERS          1031
+#define IDS_PROP_FILES            1032
+#define IDS_PROP_VERSION          1033
+#define IDS_PROP_VOLUME           1034
+#define IDS_PROP_IS_VOLUME        1035
+#define IDS_PROP_OFFSET           1036
+#define IDS_PROP_LINKS            1037
+#define IDS_PROP_NUM_BLOCKS       1038
+#define IDS_PROP_NUM_VOLUMES      1039
+
+#define IDS_PROP_BIT64            1041
+#define IDS_PROP_BIG_ENDIAN       1042
+#define IDS_PROP_CPU              1043
+#define IDS_PROP_PHY_SIZE         1044
+#define IDS_PROP_HEADERS_SIZE     1045
+#define IDS_PROP_CHECKSUM         1046
+#define IDS_PROP_CHARACTS         1047
+#define IDS_PROP_VA               1048
+#define IDS_PROP_ID               1049
+#define IDS_PROP_SHORT_NAME       1050
+#define IDS_PROP_CREATOR_APP      1051
+#define IDS_PROP_SECTOR_SIZE      1052
+#define IDS_PROP_POSIX_ATTRIB     1053
+#define IDS_PROP_SYM_LINK         1054
+#define IDS_PROP_ERROR            1055
+#define IDS_PROP_TOTAL_SIZE       1056
+#define IDS_PROP_FREE_SPACE       1057
+#define IDS_PROP_CLUSTER_SIZE     1058
+#define IDS_PROP_VOLUME_NAME      1059
+#define IDS_PROP_LOCAL_NAME       1060
+#define IDS_PROP_PROVIDER         1061
+#define IDS_PROP_NT_SECURITY      1062
+#define IDS_PROP_ALT_STREAM       1063
+#define IDS_PROP_AUX              1064
+#define IDS_PROP_DELETED          1065
+#define IDS_PROP_IS_TREE          1066
+#define IDS_PROP_SHA1             1067
+#define IDS_PROP_SHA256           1068
+#define IDS_PROP_ERROR_TYPE       1069
+#define IDS_PROP_NUM_ERRORS       1070
+#define IDS_PROP_ERROR_FLAGS      1071
+#define IDS_PROP_WARNING_FLAGS    1072
+#define IDS_PROP_WARNING          1073
+#define IDS_PROP_NUM_STREAMS      1074
+#define IDS_PROP_NUM_ALT_STREAMS  1075
+#define IDS_PROP_ALT_STREAMS_SIZE 1076
+#define IDS_PROP_VIRTUAL_SIZE     1077
+#define IDS_PROP_UNPACK_SIZE      1078
+#define IDS_PROP_TOTAL_PHY_SIZE   1079
+#define IDS_PROP_VOLUME_INDEX     1080
+#define IDS_PROP_SUBTYPE          1081
+#define IDS_PROP_SHORT_COMMENT    1082
+#define IDS_PROP_CODE_PAGE        1083
+#define IDS_PROP_IS_NOT_ARC_TYPE  1084
+#define IDS_PROP_PHY_SIZE_CANT_BE_DETECTED 1085
+#define IDS_PROP_ZEROS_TAIL_IS_ALLOWED 1086
+#define IDS_PROP_TAIL_SIZE        1087
+#define IDS_PROP_EMB_STUB_SIZE    1088
+#define IDS_PROP_NT_REPARSE       1089
+#define IDS_PROP_HARD_LINK        1090
+#define IDS_PROP_INODE            1091
+#define IDS_PROP_STREAM_ID        1092
+#define IDS_PROP_READ_ONLY        1093
+#define IDS_PROP_OUT_NAME         1094
+#define IDS_PROP_COPY_LINK        1095
diff --git a/CPP/7zip/UI/FileManager/RegistryAssociations.cpp b/CPP/7zip/UI/FileManager/RegistryAssociations.cpp
new file mode 100644
index 0000000..e48dbb4
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/RegistryAssociations.cpp
@@ -0,0 +1,167 @@
+// RegistryAssociations.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/StringToInt.h"
+
+#include "../../../Windows/Registry.h"
+
+#include "RegistryAssociations.h"
+
+using namespace NWindows;
+using namespace NRegistry;
+
+namespace NRegistryAssoc {
+  
+// static NSynchronization::CCriticalSection g_CriticalSection;
+
+static const TCHAR * const kClasses = TEXT("Software\\Classes\\");
+// static const TCHAR * const kShellNewKeyName = TEXT("ShellNew");
+// static const TCHAR * const kShellNewDataValueName = TEXT("Data");
+static const TCHAR * const kDefaultIconKeyName = TEXT("DefaultIcon");
+static const TCHAR * const kShellKeyName = TEXT("shell");
+static const TCHAR * const kOpenKeyName = TEXT("open");
+static const TCHAR * const kCommandKeyName = TEXT("command");
+static const char * const k7zipPrefix = "7-Zip.";
+
+static CSysString GetExtProgramKeyName(const CSysString &ext)
+{
+  return CSysString(k7zipPrefix) + ext;
+}
+
+static CSysString GetFullKeyPath(HKEY hkey, const CSysString &name)
+{
+  CSysString s;
+  if (hkey != HKEY_CLASSES_ROOT)
+    s = kClasses;
+  return s + name;
+}
+
+static CSysString GetExtKeyPath(HKEY hkey, const CSysString &ext)
+{
+  return GetFullKeyPath(hkey, (TEXT(".")) + ext);
+}
+
+bool CShellExtInfo::ReadFromRegistry(HKEY hkey, const CSysString &ext)
+{
+  ProgramKey.Empty();
+  IconPath.Empty();
+  IconIndex = -1;
+  // NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
+  {
+    CKey extKey;
+    if (extKey.Open(hkey, GetExtKeyPath(hkey, ext), KEY_READ) != ERROR_SUCCESS)
+      return false;
+    if (extKey.QueryValue(NULL, ProgramKey) != ERROR_SUCCESS)
+      return false;
+  }
+  {
+    CKey iconKey;
+ 
+    if (iconKey.Open(hkey, GetFullKeyPath(hkey, ProgramKey + CSysString(CHAR_PATH_SEPARATOR) + kDefaultIconKeyName), KEY_READ) == ERROR_SUCCESS)
+    {
+      UString value;
+      if (iconKey.QueryValue(NULL, value) == ERROR_SUCCESS)
+      {
+        int pos = value.ReverseFind(L',');
+        IconPath = value;
+        if (pos >= 0)
+        {
+          const wchar_t *end;
+          Int32 index = ConvertStringToInt32((const wchar_t *)value + pos + 1, &end);
+          if (*end == 0)
+          {
+            // 9.31: if there is no icon index, we use -1. Is it OK?
+            if (pos != (int)value.Len() - 1)
+              IconIndex = (int)index;
+            IconPath.SetFrom(value, pos);
+          }
+        }
+      }
+    }
+  }
+  return true;
+}
+
+bool CShellExtInfo::IsIt7Zip() const
+{
+  return ProgramKey.IsPrefixedBy_Ascii_NoCase(k7zipPrefix);
+}
+
+LONG DeleteShellExtensionInfo(HKEY hkey, const CSysString &ext)
+{
+  // NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
+  CKey rootKey;
+  rootKey.Attach(hkey);
+  LONG res = rootKey.RecurseDeleteKey(GetExtKeyPath(hkey, ext));
+  // then we delete only 7-Zip.* key.
+  rootKey.RecurseDeleteKey(GetFullKeyPath(hkey, GetExtProgramKeyName(ext)));
+  rootKey.Detach();
+  return res;
+}
+
+LONG AddShellExtensionInfo(HKEY hkey,
+    const CSysString &ext,
+    const UString &programTitle,
+    const UString &programOpenCommand,
+    const UString &iconPath, int iconIndex
+    // , const void *shellNewData, int shellNewDataSize
+    )
+{
+  LONG res = 0;
+  DeleteShellExtensionInfo(hkey, ext);
+  // NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
+  CSysString programKeyName;
+  {
+    CSysString ext2 (ext);
+    if (iconIndex < 0)
+      ext2 = "*";
+    programKeyName = GetExtProgramKeyName(ext2);
+  }
+  {
+    CKey extKey;
+    res = extKey.Create(hkey, GetExtKeyPath(hkey, ext));
+    extKey.SetValue(NULL, programKeyName);
+    /*
+    if (shellNewData != NULL)
+    {
+      CKey shellNewKey;
+      shellNewKey.Create(extKey, kShellNewKeyName);
+      shellNewKey.SetValue(kShellNewDataValueName, shellNewData, shellNewDataSize);
+    }
+    */
+  }
+  CKey programKey;
+  programKey.Create(hkey, GetFullKeyPath(hkey, programKeyName));
+  programKey.SetValue(NULL, programTitle);
+  {
+    CKey iconKey;
+    UString iconPathFull = iconPath;
+    if (iconIndex < 0)
+      iconIndex = 0;
+    // if (iconIndex >= 0)
+    {
+      iconPathFull += ',';
+      iconPathFull.Add_UInt32((UInt32)iconIndex);
+    }
+    iconKey.Create(programKey, kDefaultIconKeyName);
+    iconKey.SetValue(NULL, iconPathFull);
+  }
+
+  CKey shellKey;
+  shellKey.Create(programKey, kShellKeyName);
+  shellKey.SetValue(NULL, TEXT(""));
+
+  CKey openKey;
+  openKey.Create(shellKey, kOpenKeyName);
+  openKey.SetValue(NULL, TEXT(""));
+  
+  CKey commandKey;
+  commandKey.Create(openKey, kCommandKeyName);
+  commandKey.SetValue(NULL, programOpenCommand);
+  return res;
+}
+
+}
diff --git a/CPP/7zip/UI/FileManager/RegistryAssociations.h b/CPP/7zip/UI/FileManager/RegistryAssociations.h
new file mode 100644
index 0000000..975c9d5
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/RegistryAssociations.h
@@ -0,0 +1,31 @@
+// RegistryAssociations.h
+
+#ifndef __REGISTRY_ASSOCIATIONS_H
+#define __REGISTRY_ASSOCIATIONS_H
+
+#include "../../../Common/MyString.h"
+
+namespace NRegistryAssoc {
+
+  struct CShellExtInfo
+  {
+    CSysString ProgramKey;
+    UString IconPath;
+    int IconIndex;
+
+    bool ReadFromRegistry(HKEY hkey, const CSysString &ext);
+    bool IsIt7Zip() const;
+  };
+
+  LONG DeleteShellExtensionInfo(HKEY hkey, const CSysString &ext);
+
+  LONG AddShellExtensionInfo(HKEY hkey,
+      const CSysString &ext,
+      const UString &programTitle,
+      const UString &programOpenCommand,
+      const UString &iconPath, int iconIndex
+      // , const void *shellNewData, int shellNewDataSize
+      );
+}
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/RegistryPlugins.cpp b/CPP/7zip/UI/FileManager/RegistryPlugins.cpp
new file mode 100644
index 0000000..76a5787
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/RegistryPlugins.cpp
@@ -0,0 +1,139 @@
+// RegistryPlugins.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "IFolder.h"
+#include "RegistryPlugins.h"
+
+using namespace NWindows;
+using namespace NFile;
+
+/*
+static LPCTSTR const kLMBasePath = TEXT("Software\\7-Zip\\FM");
+
+static LPCTSTR const kPluginsKeyName = TEXT("Plugins");
+static LPCTSTR const kPluginsOpenClassIDValue = TEXT("CLSID");
+static LPCTSTR const kPluginsOptionsClassIDValue = TEXT("Options");
+static LPCTSTR const kPluginsTypeValue = TEXT("Type");
+
+static CSysString GetFileFolderPluginsKeyName()
+{
+  return CSysString(kLMBasePath) + CSysString(TEXT('\\')) +
+      CSysString(kPluginsKeyName);
+}
+
+*/
+
+typedef UINT32 (WINAPI * GetPluginPropertyFunc)(PROPID propID, PROPVARIANT *value);
+
+static bool ReadPluginInfo(CPluginInfo &pluginInfo, bool needCheckDll)
+{
+  if (needCheckDll)
+  {
+    NDLL::CLibrary lib;
+    if (!lib.LoadEx(pluginInfo.FilePath, LOAD_LIBRARY_AS_DATAFILE))
+      return false;
+  }
+  NDLL::CLibrary lib;
+  if (!lib.Load(pluginInfo.FilePath))
+    return false;
+  GetPluginPropertyFunc getPluginProperty = (GetPluginPropertyFunc)lib.GetProc("GetPluginProperty");
+  if (getPluginProperty == NULL)
+    return false;
+  
+  NCOM::CPropVariant prop;
+  if (getPluginProperty(NPlugin::kName, &prop) != S_OK)
+    return false;
+  if (prop.vt != VT_BSTR)
+    return false;
+  pluginInfo.Name = prop.bstrVal;
+  prop.Clear();
+  
+  if (getPluginProperty(NPlugin::kClassID, &prop) != S_OK)
+    return false;
+  if (prop.vt == VT_EMPTY)
+    pluginInfo.ClassIDDefined = false;
+  else if (prop.vt != VT_BSTR)
+    return false;
+  else
+  {
+    pluginInfo.ClassIDDefined = true;
+    pluginInfo.ClassID = *(const GUID *)(const void *)prop.bstrVal;
+  }
+  prop.Clear();
+  
+  if (getPluginProperty(NPlugin::kOptionsClassID, &prop) != S_OK)
+    return false;
+  if (prop.vt == VT_EMPTY)
+    pluginInfo.OptionsClassIDDefined = false;
+  else if (prop.vt != VT_BSTR)
+    return false;
+  else
+  {
+    pluginInfo.OptionsClassIDDefined = true;
+    pluginInfo.OptionsClassID = *(const GUID *)(const void *)prop.bstrVal;
+  }
+  prop.Clear();
+
+  if (getPluginProperty(NPlugin::kType, &prop) != S_OK)
+    return false;
+  if (prop.vt == VT_EMPTY)
+    pluginInfo.Type = kPluginTypeFF;
+  else if (prop.vt == VT_UI4)
+    pluginInfo.Type = (EPluginType)prop.ulVal;
+  else
+    return false;
+  return true;
+}
+
+void ReadPluginInfoList(CObjectVector<CPluginInfo> &plugins)
+{
+  plugins.Clear();
+
+  FString baseFolderPrefix = NDLL::GetModuleDirPrefix();
+  {
+    CPluginInfo pluginInfo;
+    pluginInfo.FilePath = baseFolderPrefix + FTEXT("7-zip.dll");
+    if (::ReadPluginInfo(pluginInfo, false))
+      plugins.Add(pluginInfo);
+  }
+  FString folderPath = baseFolderPrefix;
+  folderPath += "Plugins" STRING_PATH_SEPARATOR;
+  NFind::CEnumerator enumerator;
+  enumerator.SetDirPrefix(folderPath);
+  NFind::CFileInfo fileInfo;
+  while (enumerator.Next(fileInfo))
+  {
+    if (fileInfo.IsDir())
+      continue;
+    CPluginInfo pluginInfo;
+    pluginInfo.FilePath = folderPath + fileInfo.Name;
+    if (::ReadPluginInfo(pluginInfo, true))
+      plugins.Add(pluginInfo);
+  }
+}
+
+void ReadFileFolderPluginInfoList(CObjectVector<CPluginInfo> &plugins)
+{
+  ReadPluginInfoList(plugins);
+  for (unsigned i = 0; i < plugins.Size();)
+    if (plugins[i].Type != kPluginTypeFF)
+      plugins.Delete(i);
+    else
+      i++;
+  {
+    CPluginInfo p;
+    // p.FilePath.Empty();
+    p.Type = kPluginTypeFF;
+    p.Name = "7-Zip";
+    // p.ClassID = CLSID_CAgentArchiveHandler;
+    p.ClassIDDefined = true;
+    // p.OptionsClassID;
+    p.OptionsClassIDDefined = false;
+    plugins.Add(p);
+  }
+}
diff --git a/CPP/7zip/UI/FileManager/RegistryPlugins.h b/CPP/7zip/UI/FileManager/RegistryPlugins.h
new file mode 100644
index 0000000..dfa6de5
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/RegistryPlugins.h
@@ -0,0 +1,32 @@
+// RegistryPlugins.h
+
+#ifndef __REGISTRY_PLUGINS_H
+#define __REGISTRY_PLUGINS_H
+
+#include "../../../Common/MyString.h"
+
+enum EPluginType
+{
+  kPluginTypeFF = 0
+};
+
+struct CPluginInfo
+{
+  FString FilePath;
+  EPluginType Type;
+  UString Name;
+  CLSID ClassID;
+  CLSID OptionsClassID;
+  bool ClassIDDefined;
+  bool OptionsClassIDDefined;
+
+  // CSysString Extension;
+  // CSysString AddExtension;
+  // bool UpdateEnabled;
+  // bool KeepName;
+};
+
+void ReadPluginInfoList(CObjectVector<CPluginInfo> &plugins);
+void ReadFileFolderPluginInfoList(CObjectVector<CPluginInfo> &plugins);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/RegistryUtils.cpp b/CPP/7zip/UI/FileManager/RegistryUtils.cpp
new file mode 100644
index 0000000..a2fc201
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/RegistryUtils.cpp
@@ -0,0 +1,191 @@
+// RegistryUtils.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+
+#include "../../../Windows/Registry.h"
+
+#include "RegistryUtils.h"
+
+using namespace NWindows;
+using namespace NRegistry;
+
+#define REG_PATH_7Z TEXT("Software") TEXT(STRING_PATH_SEPARATOR) TEXT("7-Zip")
+
+static LPCTSTR const kCUBasePath = REG_PATH_7Z;
+static LPCTSTR const kCU_FMPath = REG_PATH_7Z TEXT(STRING_PATH_SEPARATOR) TEXT("FM");
+// static LPCTSTR const kLM_Path = REG_PATH_7Z TEXT(STRING_PATH_SEPARATOR) TEXT("FM");
+
+static LPCWSTR const kLangValueName = L"Lang";
+
+static LPCWSTR const kViewer = L"Viewer";
+static LPCWSTR const kEditor = L"Editor";
+static LPCWSTR const kDiff = L"Diff";
+static LPCWSTR const kVerCtrlPath = L"7vc";
+
+static LPCTSTR const kShowDots = TEXT("ShowDots");
+static LPCTSTR const kShowRealFileIcons = TEXT("ShowRealFileIcons");
+static LPCTSTR const kFullRow = TEXT("FullRow");
+static LPCTSTR const kShowGrid = TEXT("ShowGrid");
+static LPCTSTR const kSingleClick = TEXT("SingleClick");
+static LPCTSTR const kAlternativeSelection = TEXT("AlternativeSelection");
+// static LPCTSTR const kUnderline = TEXT("Underline");
+
+static LPCTSTR const kShowSystemMenu = TEXT("ShowSystemMenu");
+
+// static LPCTSTR const kLockMemoryAdd = TEXT("LockMemoryAdd");
+static LPCTSTR const kLargePages = TEXT("LargePages");
+
+static LPCTSTR const kFlatViewName = TEXT("FlatViewArc");
+// static LPCTSTR const kShowDeletedFiles = TEXT("ShowDeleted");
+
+static void SaveCuString(LPCTSTR keyPath, LPCWSTR valuePath, LPCWSTR value)
+{
+  CKey key;
+  key.Create(HKEY_CURRENT_USER, keyPath);
+  key.SetValue(valuePath, value);
+}
+
+static void ReadCuString(LPCTSTR keyPath, LPCWSTR valuePath, UString &res)
+{
+  res.Empty();
+  CKey key;
+  if (key.Open(HKEY_CURRENT_USER, keyPath, KEY_READ) == ERROR_SUCCESS)
+    key.QueryValue(valuePath, res);
+}
+
+void SaveRegLang(const UString &path) { SaveCuString(kCUBasePath, kLangValueName, path); }
+void ReadRegLang(UString &path) { ReadCuString(kCUBasePath, kLangValueName, path); }
+
+void SaveRegEditor(bool useEditor, const UString &path) { SaveCuString(kCU_FMPath, useEditor ? kEditor : kViewer, path); }
+void ReadRegEditor(bool useEditor, UString &path) { ReadCuString(kCU_FMPath, useEditor ? kEditor : kViewer, path); }
+
+void SaveRegDiff(const UString &path) { SaveCuString(kCU_FMPath, kDiff, path); }
+void ReadRegDiff(UString &path) { ReadCuString(kCU_FMPath, kDiff, path); }
+
+void ReadReg_VerCtrlPath(UString &path) { ReadCuString(kCU_FMPath, kVerCtrlPath, path); }
+
+static void Save7ZipOption(LPCTSTR value, bool enabled)
+{
+  CKey key;
+  key.Create(HKEY_CURRENT_USER, kCUBasePath);
+  key.SetValue(value, enabled);
+}
+
+static void SaveOption(LPCTSTR value, bool enabled)
+{
+  CKey key;
+  key.Create(HKEY_CURRENT_USER, kCU_FMPath);
+  key.SetValue(value, enabled);
+}
+
+static bool Read7ZipOption(LPCTSTR value, bool defaultValue)
+{
+  CKey key;
+  if (key.Open(HKEY_CURRENT_USER, kCUBasePath, KEY_READ) == ERROR_SUCCESS)
+  {
+    bool enabled;
+    if (key.QueryValue(value, enabled) == ERROR_SUCCESS)
+      return enabled;
+  }
+  return defaultValue;
+}
+
+static void ReadOption(CKey &key, LPCTSTR value, bool &dest)
+{
+  bool enabled = false;
+  if (key.QueryValue(value, enabled) == ERROR_SUCCESS)
+    dest = enabled;
+}
+
+/*
+static void SaveLmOption(LPCTSTR value, bool enabled)
+{
+  CKey key;
+  key.Create(HKEY_LOCAL_MACHINE, kLM_Path);
+  key.SetValue(value, enabled);
+}
+
+static bool ReadLmOption(LPCTSTR value, bool defaultValue)
+{
+  CKey key;
+  if (key.Open(HKEY_LOCAL_MACHINE, kLM_Path, KEY_READ) == ERROR_SUCCESS)
+  {
+    bool enabled;
+    if (key.QueryValue(value, enabled) == ERROR_SUCCESS)
+      return enabled;
+  }
+  return defaultValue;
+}
+*/
+
+void CFmSettings::Save() const
+{
+  SaveOption(kShowDots, ShowDots);
+  SaveOption(kShowRealFileIcons, ShowRealFileIcons);
+  SaveOption(kFullRow, FullRow);
+  SaveOption(kShowGrid, ShowGrid);
+  SaveOption(kSingleClick, SingleClick);
+  SaveOption(kAlternativeSelection, AlternativeSelection);
+  // SaveOption(kUnderline, Underline);
+
+  SaveOption(kShowSystemMenu, ShowSystemMenu);
+}
+
+void CFmSettings::Load()
+{
+  ShowDots = false;
+  ShowRealFileIcons = false;
+  FullRow = false;
+  ShowGrid = false;
+  SingleClick = false;
+  AlternativeSelection = false;
+  // Underline = false;
+
+  ShowSystemMenu = false;
+
+  CKey key;
+  if (key.Open(HKEY_CURRENT_USER, kCU_FMPath, KEY_READ) == ERROR_SUCCESS)
+  {
+    ReadOption(key, kShowDots, ShowDots);
+    ReadOption(key, kShowRealFileIcons, ShowRealFileIcons);
+    ReadOption(key, kFullRow, FullRow);
+    ReadOption(key, kShowGrid, ShowGrid);
+    ReadOption(key, kSingleClick, SingleClick);
+    ReadOption(key, kAlternativeSelection, AlternativeSelection);
+    // ReadOption(key, kUnderline, Underline);
+
+    ReadOption(key, kShowSystemMenu, ShowSystemMenu );
+  }
+}
+
+
+// void SaveLockMemoryAdd(bool enable) { SaveLmOption(kLockMemoryAdd, enable); }
+// bool ReadLockMemoryAdd() { return ReadLmOption(kLockMemoryAdd, true); }
+
+void SaveLockMemoryEnable(bool enable) { Save7ZipOption(kLargePages, enable); }
+bool ReadLockMemoryEnable() { return Read7ZipOption(kLargePages, false); }
+
+static CSysString GetFlatViewName(UInt32 panelIndex)
+{
+  TCHAR panelString[16];
+  ConvertUInt32ToString(panelIndex, panelString);
+  return (CSysString)kFlatViewName + panelString;
+}
+
+void SaveFlatView(UInt32 panelIndex, bool enable) { SaveOption(GetFlatViewName(panelIndex), enable); }
+
+bool ReadFlatView(UInt32 panelIndex)
+{
+  bool enabled = false;
+  CKey key;
+  if (key.Open(HKEY_CURRENT_USER, kCU_FMPath, KEY_READ) == ERROR_SUCCESS)
+    ReadOption(key, GetFlatViewName(panelIndex), enabled);
+  return enabled;
+}
+
+/*
+void Save_ShowDeleted(bool enable) { SaveOption(kShowDeletedFiles, enable); }
+bool Read_ShowDeleted() { return ReadOption(kShowDeletedFiles, false); }
+*/
diff --git a/CPP/7zip/UI/FileManager/RegistryUtils.h b/CPP/7zip/UI/FileManager/RegistryUtils.h
new file mode 100644
index 0000000..b85d670
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/RegistryUtils.h
@@ -0,0 +1,50 @@
+// RegistryUtils.h
+
+#ifndef __REGISTRY_UTILS_H
+#define __REGISTRY_UTILS_H
+
+#include "../../../Common/MyTypes.h"
+#include "../../../Common/MyString.h"
+
+void SaveRegLang(const UString &path);
+void ReadRegLang(UString &path);
+
+void SaveRegEditor(bool useEditor, const UString &path);
+void ReadRegEditor(bool useEditor, UString &path);
+
+void SaveRegDiff(const UString &path);
+void ReadRegDiff(UString &path);
+
+void ReadReg_VerCtrlPath(UString &path);
+
+struct CFmSettings
+{
+  bool ShowDots;
+  bool ShowRealFileIcons;
+  bool FullRow;
+  bool ShowGrid;
+  bool SingleClick;
+  bool AlternativeSelection;
+  // bool Underline;
+
+  bool ShowSystemMenu;
+
+  void Save() const;
+  void Load();
+};
+
+// void SaveLockMemoryAdd(bool enable);
+// bool ReadLockMemoryAdd();
+
+bool ReadLockMemoryEnable();
+void SaveLockMemoryEnable(bool enable);
+
+void SaveFlatView(UInt32 panelIndex, bool enable);
+bool ReadFlatView(UInt32 panelIndex);
+
+/*
+void Save_ShowDeleted(bool enable);
+bool Read_ShowDeleted();
+*/
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/RootFolder.cpp b/CPP/7zip/UI/FileManager/RootFolder.cpp
new file mode 100644
index 0000000..84844c7
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/RootFolder.cpp
@@ -0,0 +1,318 @@
+// RootFolder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyWindows.h"
+
+#include <ShlObj.h>
+
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "../../PropID.h"
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+#define USE_WIN_PATHS
+#endif
+
+static const unsigned kNumRootFolderItems =
+  #ifdef USE_WIN_PATHS
+  4
+  #else
+  1
+  #endif
+  ;
+
+
+#include "FSFolder.h"
+#include "LangUtils.h"
+#ifdef USE_WIN_PATHS
+#include "NetFolder.h"
+#include "FSDrives.h"
+#include "AltStreamsFolder.h"
+#endif
+#include "RootFolder.h"
+#include "SysIconUtils.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+
+static const Byte  kProps[] =
+{
+  kpidName
+};
+
+UString RootFolder_GetName_Computer(int &iconIndex);
+UString RootFolder_GetName_Computer(int &iconIndex)
+{
+  #ifdef USE_WIN_PATHS
+  iconIndex = GetIconIndexForCSIDL(CSIDL_DRIVES);
+  #else
+  GetRealIconIndex(FSTRING_PATH_SEPARATOR, FILE_ATTRIBUTE_DIRECTORY, iconIndex);
+  #endif
+  return LangString(IDS_COMPUTER);
+}
+
+UString RootFolder_GetName_Network(int &iconIndex);
+UString RootFolder_GetName_Network(int &iconIndex)
+{
+  iconIndex = GetIconIndexForCSIDL(CSIDL_NETWORK);
+  return LangString(IDS_NETWORK);
+}
+
+UString RootFolder_GetName_Documents(int &iconIndex);
+UString RootFolder_GetName_Documents(int &iconIndex)
+{
+  iconIndex = GetIconIndexForCSIDL(CSIDL_PERSONAL);
+  return LangString(IDS_DOCUMENTS);
+}
+
+enum
+{
+  ROOT_INDEX_COMPUTER = 0
+  #ifdef USE_WIN_PATHS
+  , ROOT_INDEX_DOCUMENTS
+  , ROOT_INDEX_NETWORK
+  , ROOT_INDEX_VOLUMES
+  #endif
+};
+
+#ifdef USE_WIN_PATHS
+static const char * const kVolPrefix = "\\\\.";
+#endif
+
+void CRootFolder::Init()
+{
+  _names[ROOT_INDEX_COMPUTER] = RootFolder_GetName_Computer(_iconIndices[ROOT_INDEX_COMPUTER]);
+  #ifdef USE_WIN_PATHS
+  _names[ROOT_INDEX_DOCUMENTS] = RootFolder_GetName_Documents(_iconIndices[ROOT_INDEX_DOCUMENTS]);
+  _names[ROOT_INDEX_NETWORK] = RootFolder_GetName_Network(_iconIndices[ROOT_INDEX_NETWORK]);
+  _names[ROOT_INDEX_VOLUMES] = kVolPrefix;
+  _iconIndices[ROOT_INDEX_VOLUMES] = GetIconIndexForCSIDL(CSIDL_DRIVES);
+  #endif
+}
+
+STDMETHODIMP CRootFolder::LoadItems()
+{
+  Init();
+  return S_OK;
+}
+
+STDMETHODIMP CRootFolder::GetNumberOfItems(UInt32 *numItems)
+{
+  *numItems = kNumRootFolderItems;
+  return S_OK;
+}
+
+STDMETHODIMP CRootFolder::GetProperty(UInt32 itemIndex, PROPID propID, PROPVARIANT *value)
+{
+  NCOM::CPropVariant prop;
+  switch (propID)
+  {
+    case kpidIsDir:  prop = true; break;
+    case kpidName:  prop = _names[itemIndex]; break;
+  }
+  prop.Detach(value);
+  return S_OK;
+}
+
+typedef BOOL (WINAPI *SHGetSpecialFolderPathWp)(HWND hwnd, LPWSTR pszPath, int csidl, BOOL fCreate);
+typedef BOOL (WINAPI *SHGetSpecialFolderPathAp)(HWND hwnd, LPSTR pszPath, int csidl, BOOL fCreate);
+
+static UString GetMyDocsPath()
+{
+  UString us;
+  WCHAR s[MAX_PATH + 1];
+  SHGetSpecialFolderPathWp getW = (SHGetSpecialFolderPathWp)
+      #ifdef UNDER_CE
+      My_GetProcAddress(GetModuleHandle(TEXT("coredll.dll")), "SHGetSpecialFolderPath");
+      #else
+      My_GetProcAddress(GetModuleHandle(TEXT("shell32.dll")), "SHGetSpecialFolderPathW");
+      #endif
+  if (getW && getW(0, s, CSIDL_PERSONAL, FALSE))
+    us = s;
+  #ifndef _UNICODE
+  else
+  {
+    SHGetSpecialFolderPathAp getA = (SHGetSpecialFolderPathAp)
+        (void *)::GetProcAddress(::GetModuleHandleA("shell32.dll"), "SHGetSpecialFolderPathA");
+    CHAR s2[MAX_PATH + 1];
+    if (getA && getA(0, s2, CSIDL_PERSONAL, FALSE))
+      us = GetUnicodeString(s2);
+  }
+  #endif
+  NFile::NName::NormalizeDirPathPrefix(us);
+  return us;
+}
+
+STDMETHODIMP CRootFolder::BindToFolder(UInt32 index, IFolderFolder **resultFolder)
+{
+  *resultFolder = NULL;
+  CMyComPtr<IFolderFolder> subFolder;
+
+  #ifdef USE_WIN_PATHS
+  if (index == ROOT_INDEX_COMPUTER || index == ROOT_INDEX_VOLUMES)
+  {
+    CFSDrives *fsDrivesSpec = new CFSDrives;
+    subFolder = fsDrivesSpec;
+    fsDrivesSpec->Init(index == ROOT_INDEX_VOLUMES);
+  }
+  else if (index == ROOT_INDEX_NETWORK)
+  {
+    CNetFolder *netFolderSpec = new CNetFolder;
+    subFolder = netFolderSpec;
+    netFolderSpec->Init(0, 0, _names[ROOT_INDEX_NETWORK] + WCHAR_PATH_SEPARATOR);
+  }
+  else if (index == ROOT_INDEX_DOCUMENTS)
+  {
+    UString s = GetMyDocsPath();
+    if (!s.IsEmpty())
+    {
+      NFsFolder::CFSFolder *fsFolderSpec = new NFsFolder::CFSFolder;
+      subFolder = fsFolderSpec;
+      RINOK(fsFolderSpec->Init(us2fs(s)));
+    }
+  }
+  #else
+  if (index == ROOT_INDEX_COMPUTER)
+  {
+    NFsFolder::CFSFolder *fsFolder = new NFsFolder::CFSFolder;
+    subFolder = fsFolder;
+    fsFolder->InitToRoot();
+  }
+  #endif
+  else
+    return E_INVALIDARG;
+
+  *resultFolder = subFolder.Detach();
+  return S_OK;
+}
+
+static bool AreEqualNames(const UString &path, const wchar_t *name)
+{
+  unsigned len = MyStringLen(name);
+  if (len > path.Len() || len + 1 < path.Len())
+    return false;
+  if (len + 1 == path.Len() && !IS_PATH_SEPAR(path[len]))
+    return false;
+  return path.IsPrefixedBy(name);
+}
+
+STDMETHODIMP CRootFolder::BindToFolder(const wchar_t *name, IFolderFolder **resultFolder)
+{
+  *resultFolder = 0;
+  UString name2 = name;
+  name2.Trim();
+  
+  if (name2.IsEmpty())
+  {
+    CRootFolder *rootFolderSpec = new CRootFolder;
+    CMyComPtr<IFolderFolder> rootFolder = rootFolderSpec;
+    rootFolderSpec->Init();
+    *resultFolder = rootFolder.Detach();
+    return S_OK;
+  }
+  
+  for (unsigned i = 0; i < kNumRootFolderItems; i++)
+    if (AreEqualNames(name2, _names[i]))
+      return BindToFolder((UInt32)i, resultFolder);
+  
+  #ifdef USE_WIN_PATHS
+  if (AreEqualNames(name2, L"My Documents") ||
+      AreEqualNames(name2, L"Documents"))
+    return BindToFolder((UInt32)ROOT_INDEX_DOCUMENTS, resultFolder);
+  #else
+  if (name2 == WSTRING_PATH_SEPARATOR)
+    return BindToFolder((UInt32)ROOT_INDEX_COMPUTER, resultFolder);
+  #endif
+  
+  if (AreEqualNames(name2, L"My Computer") ||
+      AreEqualNames(name2, L"Computer"))
+    return BindToFolder((UInt32)ROOT_INDEX_COMPUTER, resultFolder);
+  
+  if (name2 == WSTRING_PATH_SEPARATOR)
+  {
+    CMyComPtr<IFolderFolder> subFolder = this;
+    *resultFolder = subFolder.Detach();
+    return S_OK;
+  }
+
+  if (name2.Len() < 2)
+    return E_INVALIDARG;
+
+  CMyComPtr<IFolderFolder> subFolder;
+  
+  #ifdef USE_WIN_PATHS
+  if (name2.IsPrefixedBy_Ascii_NoCase(kVolPrefix))
+  {
+    CFSDrives *folderSpec = new CFSDrives;
+    subFolder = folderSpec;
+    folderSpec->Init(true);
+  }
+  else if (name2.IsEqualTo(NFile::NName::kSuperPathPrefix))
+  {
+    CFSDrives *folderSpec = new CFSDrives;
+    subFolder = folderSpec;
+    folderSpec->Init(false, true);
+  }
+  else if (name2.Back() == ':')
+  {
+    NAltStreamsFolder::CAltStreamsFolder *folderSpec = new NAltStreamsFolder::CAltStreamsFolder;
+    subFolder = folderSpec;
+    if (folderSpec->Init(us2fs(name2)) != S_OK)
+      return E_INVALIDARG;
+  }
+  else
+  #endif
+  {
+    NFile::NName::NormalizeDirPathPrefix(name2);
+    NFsFolder::CFSFolder *fsFolderSpec = new NFsFolder::CFSFolder;
+    subFolder = fsFolderSpec;
+    if (fsFolderSpec->Init(us2fs(name2)) != S_OK)
+    {
+      #ifdef USE_WIN_PATHS
+      if (IS_PATH_SEPAR(name2[0]))
+      {
+        CNetFolder *netFolderSpec = new CNetFolder;
+        subFolder = netFolderSpec;
+        netFolderSpec->Init(name2);
+      }
+      else
+      #endif
+        return E_INVALIDARG;
+    }
+  }
+  
+  *resultFolder = subFolder.Detach();
+  return S_OK;
+}
+
+STDMETHODIMP CRootFolder::BindToParentFolder(IFolderFolder **resultFolder)
+{
+  *resultFolder = 0;
+  return S_OK;
+}
+
+IMP_IFolderFolder_Props(CRootFolder)
+
+STDMETHODIMP CRootFolder::GetFolderProperty(PROPID propID, PROPVARIANT *value)
+{
+  NCOM::CPropVariant prop;
+  switch (propID)
+  {
+    case kpidType: prop = "RootFolder"; break;
+    case kpidPath: prop = ""; break;
+  }
+  prop.Detach(value);
+  return S_OK;
+}
+
+STDMETHODIMP CRootFolder::GetSystemIconIndex(UInt32 index, Int32 *iconIndex)
+{
+  *iconIndex = _iconIndices[index];
+  return S_OK;
+}
diff --git a/CPP/7zip/UI/FileManager/RootFolder.h b/CPP/7zip/UI/FileManager/RootFolder.h
new file mode 100644
index 0000000..e253783
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/RootFolder.h
@@ -0,0 +1,27 @@
+// RootFolder.h
+
+#ifndef __ROOT_FOLDER_H
+#define __ROOT_FOLDER_H
+
+#include "../../../Common/MyString.h"
+
+#include "IFolder.h"
+
+const unsigned kNumRootFolderItems_Max = 4;
+
+class CRootFolder:
+  public IFolderFolder,
+  public IFolderGetSystemIconIndex,
+  public CMyUnknownImp
+{
+  UString _names[kNumRootFolderItems_Max];
+  int _iconIndices[kNumRootFolderItems_Max];
+
+public:
+  MY_UNKNOWN_IMP1(IFolderGetSystemIconIndex)
+  INTERFACE_FolderFolder(;)
+  STDMETHOD(GetSystemIconIndex)(UInt32 index, Int32 *iconIndex);
+  void Init();
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/SettingsPage.cpp b/CPP/7zip/UI/FileManager/SettingsPage.cpp
new file mode 100644
index 0000000..2868721
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SettingsPage.cpp
@@ -0,0 +1,350 @@
+// SettingsPage.cpp
+
+#include "StdAfx.h"
+
+// #include "../../../Common/IntToString.h"
+// #include "../../../Common/StringConvert.h"
+
+#ifndef UNDER_CE
+#include "../../../Windows/MemoryLock.h"
+// #include "../../../Windows/System.h"
+#endif
+
+// #include "../Common/ZipRegistry.h"
+
+#include "HelpUtils.h"
+#include "LangUtils.h"
+#include "RegistryUtils.h"
+#include "SettingsPage.h"
+#include "SettingsPageRes.h"
+
+using namespace NWindows;
+
+static const UInt32 kLangIDs[] =
+{
+  IDX_SETTINGS_SHOW_DOTS,
+  IDX_SETTINGS_SHOW_REAL_FILE_ICONS,
+  IDX_SETTINGS_SHOW_SYSTEM_MENU,
+  IDX_SETTINGS_FULL_ROW,
+  IDX_SETTINGS_SHOW_GRID,
+  IDX_SETTINGS_SINGLE_CLICK,
+  IDX_SETTINGS_ALTERNATIVE_SELECTION,
+  IDX_SETTINGS_LARGE_PAGES
+  // , IDT_COMPRESS_MEMORY
+};
+
+#define kSettingsTopic "FM/options.htm#settings"
+
+extern bool IsLargePageSupported();
+
+/*
+static void AddMemSize(UString &res, UInt64 size, bool needRound = false)
+{
+  char c;
+  unsigned moveBits = 0;
+  if (needRound)
+  {
+    UInt64 rn = 0;
+    if (size >= (1 << 31))
+      rn = (1 << 28) - 1;
+    UInt32 kRound = (1 << 20) - 1;
+    if (rn < kRound)
+      rn = kRound;
+    size += rn;
+    size &= ~rn;
+  }
+  if (size >= ((UInt64)1 << 31) && (size & 0x3FFFFFFF) == 0)
+    { moveBits = 30; c = 'G'; }
+  else
+    { moveBits = 20; c = 'M'; }
+  res.Add_UInt64(size >> moveBits);
+  res.Add_Space();
+  if (moveBits != 0)
+    res += c;
+  res += 'B';
+}
+
+
+int CSettingsPage::AddMemComboItem(UInt64 size, UInt64 percents, bool isDefault)
+{
+  UString sUser;
+  UString sRegistry;
+  if (size == 0)
+  {
+    UString s;
+    s.Add_UInt64(percents);
+    s += '%';
+    if (isDefault)
+      sUser = "* ";
+    else
+      sRegistry = s;
+    sUser += s;
+  }
+  else
+  {
+    AddMemSize(sUser, size);
+    sRegistry = sUser;
+    for (;;)
+    {
+      int pos = sRegistry.Find(L' ');
+      if (pos < 0)
+        break;
+      sRegistry.Delete(pos);
+    }
+    if (!sRegistry.IsEmpty())
+      if (sRegistry.Back() == 'B')
+        sRegistry.DeleteBack();
+  }
+  const int index = (int)_memCombo.AddString(sUser);
+  _memCombo.SetItemData(index, _memLimitStrings.Size());
+  _memLimitStrings.Add(sRegistry);
+  return index;
+}
+*/
+
+bool CSettingsPage::OnInit()
+{
+  _wasChanged = false;
+  _largePages_wasChanged = false;
+  /*
+  _wasChanged_MemLimit = false;
+  _memLimitStrings.Clear();
+  _memCombo.Attach(GetItem(IDC_SETTINGS_MEM));
+  */
+
+  LangSetDlgItems(*this, kLangIDs, ARRAY_SIZE(kLangIDs));
+
+  CFmSettings st;
+  st.Load();
+
+  CheckButton(IDX_SETTINGS_SHOW_DOTS, st.ShowDots);
+  CheckButton(IDX_SETTINGS_SHOW_REAL_FILE_ICONS, st.ShowRealFileIcons);
+  CheckButton(IDX_SETTINGS_FULL_ROW, st.FullRow);
+  CheckButton(IDX_SETTINGS_SHOW_GRID, st.ShowGrid);
+  CheckButton(IDX_SETTINGS_SINGLE_CLICK, st.SingleClick);
+  CheckButton(IDX_SETTINGS_ALTERNATIVE_SELECTION, st.AlternativeSelection);
+  // CheckButton(IDX_SETTINGS_UNDERLINE, st.Underline);
+
+  CheckButton(IDX_SETTINGS_SHOW_SYSTEM_MENU, st.ShowSystemMenu);
+  
+  if (IsLargePageSupported())
+    CheckButton(IDX_SETTINGS_LARGE_PAGES, ReadLockMemoryEnable());
+  else
+    EnableItem(IDX_SETTINGS_LARGE_PAGES, false);
+
+
+  /*
+  NCompression::CMemUse mu;
+  bool needSetCur = NCompression::MemLimit_Load(mu);
+  UInt64 curMemLimit;
+  {
+    AddMemComboItem(0, 90, true);
+    _memCombo.SetCurSel(0);
+  }
+  if (mu.IsPercent)
+  {
+    const int index = AddMemComboItem(0, mu.Val);
+    _memCombo.SetCurSel(index);
+    needSetCur = false;
+  }
+  {
+    _ramSize = (UInt64)(sizeof(size_t)) << 29;
+    _ramSize_Defined = NSystem::GetRamSize(_ramSize);
+    UString s;
+    if (_ramSize_Defined)
+    {
+      s += "/ ";
+      AddMemSize(s, _ramSize, true);
+    }
+    SetItemText(IDT_SETTINGS_MEM_RAM, s);
+
+    curMemLimit = mu.GetBytes(_ramSize);
+
+    // size = 100 << 20; // for debug only;
+    for (unsigned i = (27) * 2;; i++)
+    {
+      UInt64 size = (UInt64)(2 + (i & 1)) << (i / 2);
+      if (i > (20 + sizeof(size_t) * 3 * 1 - 1) * 2)
+        size = (UInt64)(Int64)-1;
+      if (needSetCur && (size >= curMemLimit))
+      {
+        const int index = AddMemComboItem(curMemLimit);
+        _memCombo.SetCurSel(index);
+        needSetCur = false;
+        if (size == curMemLimit)
+          continue;
+      }
+      if (size == (UInt64)(Int64)-1)
+        break;
+      AddMemComboItem(size);
+    }
+  }
+  */
+  
+  // EnableSubItems();
+
+  return CPropertyPage::OnInit();
+}
+
+/*
+void CSettingsPage::EnableSubItems()
+{
+  EnableItem(IDX_SETTINGS_UNDERLINE, IsButtonCheckedBool(IDX_SETTINGS_SINGLE_CLICK));
+}
+*/
+
+/*
+static void AddSize_MB(UString &s, UInt64 size)
+{
+  s.Add_UInt64((size + (1 << 20) - 1) >> 20);
+  s += " MB";
+}
+*/
+
+LONG CSettingsPage::OnApply()
+{
+  if (_wasChanged)
+  {
+    CFmSettings st;
+    st.ShowDots = IsButtonCheckedBool(IDX_SETTINGS_SHOW_DOTS);
+    st.ShowRealFileIcons = IsButtonCheckedBool(IDX_SETTINGS_SHOW_REAL_FILE_ICONS);
+    st.FullRow = IsButtonCheckedBool(IDX_SETTINGS_FULL_ROW);
+    st.ShowGrid = IsButtonCheckedBool(IDX_SETTINGS_SHOW_GRID);
+    st.SingleClick = IsButtonCheckedBool(IDX_SETTINGS_SINGLE_CLICK);
+    st.AlternativeSelection = IsButtonCheckedBool(IDX_SETTINGS_ALTERNATIVE_SELECTION);
+    // st.Underline = IsButtonCheckedBool(IDX_SETTINGS_UNDERLINE);
+    
+    st.ShowSystemMenu = IsButtonCheckedBool(IDX_SETTINGS_SHOW_SYSTEM_MENU);
+
+    st.Save();
+    _wasChanged = false;
+  }
+
+  #ifndef UNDER_CE
+  if (_largePages_wasChanged)
+  {
+    if (IsLargePageSupported())
+    {
+      bool enable = IsButtonCheckedBool(IDX_SETTINGS_LARGE_PAGES);
+      NSecurity::EnablePrivilege_LockMemory(enable);
+      SaveLockMemoryEnable(enable);
+    }
+    _largePages_wasChanged = false;
+  }
+  #endif
+
+  /*
+  if (_wasChanged_MemLimit)
+  {
+    const unsigned index = (int)_memCombo.GetItemData_of_CurSel();
+    const UString str = _memLimitStrings[index];
+
+    bool needSave = true;
+    
+    NCompression::CMemUse mu;
+
+    if (_ramSize_Defined)
+      mu.Parse(str);
+    if (mu.IsDefined)
+    {
+      const UInt64 usage64 = mu.GetBytes(_ramSize);
+      if (_ramSize <= usage64)
+      {
+        UString s2 = LangString(IDT_COMPRESS_MEMORY);
+        if (s2.IsEmpty())
+          GetItemText(IDT_COMPRESS_MEMORY, s2);
+        UString s;
+        
+        s += "The selected value is not safe for system performance.";
+        s.Add_LF();
+        s += "The memory consumption for compression operation will exceed RAM size.";
+        s.Add_LF();
+        s.Add_LF();
+        AddSize_MB(s, usage64);
+        
+        if (!s2.IsEmpty())
+        {
+          s += " : ";
+          s += s2;
+        }
+        
+        s.Add_LF();
+        AddSize_MB(s, _ramSize);
+        s += " : RAM";
+        
+        s.Add_LF();
+        s.Add_LF();
+        s += "Are you sure you want set that unsafe value for memory usage?";
+        
+        int res = MessageBoxW(*this, s, L"7-Zip", MB_YESNOCANCEL | MB_ICONQUESTION);
+        if (res != IDYES)
+          needSave = false;
+      }
+    }
+
+    if (needSave)
+    {
+      NCompression::MemLimit_Save(str);
+      _wasChanged_MemLimit = false;
+    }
+    else
+      return PSNRET_INVALID_NOCHANGEPAGE;
+  }
+  */
+    
+  return PSNRET_NOERROR;
+}
+
+void CSettingsPage::OnNotifyHelp()
+{
+  ShowHelpWindow(kSettingsTopic);
+}
+
+/*
+bool CSettingsPage::OnCommand(int code, int itemID, LPARAM param)
+{
+  if (code == CBN_SELCHANGE)
+  {
+    switch (itemID)
+    {
+      case IDC_SETTINGS_MEM:
+      {
+        _wasChanged_MemLimit = true;
+        Changed();
+        break;
+      }
+    }
+  }
+  return CPropertyPage::OnCommand(code, itemID, param);
+}
+*/
+
+bool CSettingsPage::OnButtonClicked(int buttonID, HWND buttonHWND)
+{
+  switch (buttonID)
+  {
+    case IDX_SETTINGS_SINGLE_CLICK:
+    /*
+      EnableSubItems();
+      break;
+    */
+    case IDX_SETTINGS_SHOW_DOTS:
+    case IDX_SETTINGS_SHOW_SYSTEM_MENU:
+    case IDX_SETTINGS_SHOW_REAL_FILE_ICONS:
+    case IDX_SETTINGS_FULL_ROW:
+    case IDX_SETTINGS_SHOW_GRID:
+    case IDX_SETTINGS_ALTERNATIVE_SELECTION:
+      _wasChanged = true;
+      break;
+
+    case IDX_SETTINGS_LARGE_PAGES:
+      _largePages_wasChanged = true;
+      break;
+
+    default:
+      return CPropertyPage::OnButtonClicked(buttonID, buttonHWND);
+  }
+
+  Changed();
+  return true;
+}
diff --git a/CPP/7zip/UI/FileManager/SettingsPage.h b/CPP/7zip/UI/FileManager/SettingsPage.h
new file mode 100644
index 0000000..f3f57a4
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SettingsPage.h
@@ -0,0 +1,33 @@
+// SettingsPage.h
+ 
+#ifndef __SETTINGS_PAGE_H
+#define __SETTINGS_PAGE_H
+
+#include "../../../Windows/Control/PropertyPage.h"
+#include "../../../Windows/Control/ComboBox.h"
+#include "../../../Windows/Control/Edit.h"
+
+class CSettingsPage: public NWindows::NControl::CPropertyPage
+{
+  bool _wasChanged;
+  bool _largePages_wasChanged;
+  /*
+  bool _wasChanged_MemLimit;
+  NWindows::NControl::CComboBox _memCombo;
+  UStringVector _memLimitStrings;
+  UInt64 _ramSize;
+  UInt64 _ramSize_Defined;
+ 
+  int AddMemComboItem(UInt64 size, UInt64 percents = 0, bool isDefault = false);
+  */
+
+  // void EnableSubItems();
+  // bool OnCommand(int code, int itemID, LPARAM param);
+  bool OnButtonClicked(int buttonID, HWND buttonHWND);
+  virtual bool OnInit();
+  virtual void OnNotifyHelp();
+  virtual LONG OnApply();
+public:
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/SettingsPage.rc b/CPP/7zip/UI/FileManager/SettingsPage.rc
new file mode 100644
index 0000000..baab484
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SettingsPage.rc
@@ -0,0 +1,22 @@
+#include "SettingsPageRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 240
+#define yc 250
+
+IDD_SETTINGS  MY_PAGE
+#include "SettingsPage2.rc"
+
+
+#ifdef UNDER_CE
+
+#undef m
+#undef xc
+
+#define m 4
+#define xc (SMALL_PAGE_SIZE_X + 8)
+
+IDD_SETTINGS_2  MY_PAGE
+#include "SettingsPage2.rc"
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/SettingsPage2.rc b/CPP/7zip/UI/FileManager/SettingsPage2.rc
new file mode 100644
index 0000000..cf90742
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SettingsPage2.rc
@@ -0,0 +1,19 @@
+// #define g1xs 60
+
+CAPTION "Settings"
+BEGIN 
+  CONTROL  "Show "".."" item",      IDX_SETTINGS_SHOW_DOTS,            MY_CHECKBOX, m,  8, xc, 10
+  CONTROL  "Show real file &icons", IDX_SETTINGS_SHOW_REAL_FILE_ICONS, MY_CHECKBOX, m, 22, xc, 10
+  CONTROL  "&Full row select",      IDX_SETTINGS_FULL_ROW,             MY_CHECKBOX, m, 36, xc, 10
+  CONTROL  "Show &grid lines",      IDX_SETTINGS_SHOW_GRID,            MY_CHECKBOX, m, 50, xc, 10
+  CONTROL  "&Single-click to open an item", IDX_SETTINGS_SINGLE_CLICK, MY_CHECKBOX, m, 64, xc, 10
+  CONTROL  "&Alternative selection mode", IDX_SETTINGS_ALTERNATIVE_SELECTION, MY_CHECKBOX, m, 78, xc, 10
+
+  CONTROL  "Show system &menu",     IDX_SETTINGS_SHOW_SYSTEM_MENU,     MY_CHECKBOX, m, 100, xc, 10
+
+  CONTROL  "Use &large memory pages", IDX_SETTINGS_LARGE_PAGES,        MY_CHECKBOX, m, 122, xc, 10
+
+  // LTEXT     "Memory usage for Compressing:", IDT_COMPRESS_MEMORY, m, 140, xc, 8
+  // COMBOBOX  IDC_SETTINGS_MEM, m , 152, g1xs, yc - 152, MY_COMBO
+  // LTEXT     "/ RAM", IDT_SETTINGS_MEM_RAM, m + g1xs + m, 154, xc - g1xs - m, MY_TEXT_NOPREFIX
+END
diff --git a/CPP/7zip/UI/FileManager/SettingsPageRes.h b/CPP/7zip/UI/FileManager/SettingsPageRes.h
new file mode 100644
index 0000000..e990bab
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SettingsPageRes.h
@@ -0,0 +1,17 @@
+#define IDD_SETTINGS     2500
+#define IDD_SETTINGS_2  12500
+
+#define IDX_SETTINGS_SHOW_DOTS              2501
+#define IDX_SETTINGS_SHOW_REAL_FILE_ICONS   2502
+#define IDX_SETTINGS_SHOW_SYSTEM_MENU       2503
+#define IDX_SETTINGS_FULL_ROW               2504
+#define IDX_SETTINGS_SHOW_GRID              2505
+#define IDX_SETTINGS_SINGLE_CLICK           2506
+#define IDX_SETTINGS_ALTERNATIVE_SELECTION  2507
+#define IDX_SETTINGS_LARGE_PAGES            2508
+
+
+// #define IDT_SETTINGS_MEM     100
+// #define IDC_SETTINGS_MEM     101
+// #define IDT_SETTINGS_MEM_RAM 102
+// #define IDT_COMPRESS_MEMORY  4017
diff --git a/CPP/7zip/UI/FileManager/SplitDialog.cpp b/CPP/7zip/UI/FileManager/SplitDialog.cpp
new file mode 100644
index 0000000..0c9fdd1
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SplitDialog.cpp
@@ -0,0 +1,116 @@
+// SplitDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/FileName.h"
+
+#ifdef LANG
+#include "LangUtils.h"
+#endif
+
+#include "BrowseDialog.h"
+#include "CopyDialogRes.h"
+#include "SplitDialog.h"
+#include "SplitUtils.h"
+#include "resourceGui.h"
+
+using namespace NWindows;
+
+#ifdef LANG
+static const UInt32 kLangIDs[] =
+{
+  IDT_SPLIT_PATH,
+  IDT_SPLIT_VOLUME
+};
+#endif
+
+
+bool CSplitDialog::OnInit()
+{
+  #ifdef LANG
+  LangSetWindowText(*this, IDD_SPLIT);
+  LangSetDlgItems(*this, kLangIDs, ARRAY_SIZE(kLangIDs));
+  #endif
+  _pathCombo.Attach(GetItem(IDC_SPLIT_PATH));
+  _volumeCombo.Attach(GetItem(IDC_SPLIT_VOLUME));
+  
+  if (!FilePath.IsEmpty())
+  {
+    UString title;
+    GetText(title);
+    title.Add_Space();
+    title += FilePath;
+    SetText(title);
+  }
+  _pathCombo.SetText(Path);
+  AddVolumeItems(_volumeCombo);
+  _volumeCombo.SetCurSel(0);
+  NormalizeSize();
+  return CModalDialog::OnInit();
+}
+
+bool CSplitDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+  int mx, my;
+  GetMargins(8, mx, my);
+  int bx1, bx2, by;
+  GetItemSizes(IDCANCEL, bx1, by);
+  GetItemSizes(IDOK, bx2, by);
+  int yPos = ySize - my - by;
+  int xPos = xSize - mx - bx1;
+
+  InvalidateRect(NULL);
+
+  {
+    RECT r;
+    GetClientRectOfItem(IDB_SPLIT_PATH, r);
+    int bx = RECT_SIZE_X(r);
+    MoveItem(IDB_SPLIT_PATH, xSize - mx - bx, r.top, bx, RECT_SIZE_Y(r));
+    ChangeSubWindowSizeX(_pathCombo, xSize - mx - mx - bx - mx);
+  }
+
+  MoveItem(IDCANCEL, xPos, yPos, bx1, by);
+  MoveItem(IDOK, xPos - mx - bx2, yPos, bx2, by);
+
+  return false;
+}
+
+bool CSplitDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
+{
+  switch (buttonID)
+  {
+    case IDB_SPLIT_PATH:
+      OnButtonSetPath();
+      return true;
+  }
+  return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+}
+
+void CSplitDialog::OnButtonSetPath()
+{
+  UString currentPath;
+  _pathCombo.GetText(currentPath);
+  // UString title = "Specify a location for output folder";
+  UString title = LangString(IDS_SET_FOLDER);
+
+  UString resultPath;
+  if (!MyBrowseForFolder(*this, title, currentPath, resultPath))
+    return;
+  NFile::NName::NormalizeDirPathPrefix(resultPath);
+  _pathCombo.SetCurSel(-1);
+  _pathCombo.SetText(resultPath);
+}
+
+void CSplitDialog::OnOK()
+{
+  _pathCombo.GetText(Path);
+  UString volumeString;
+  _volumeCombo.GetText(volumeString);
+  volumeString.Trim();
+  if (!ParseVolumeSizes(volumeString, VolumeSizes) || VolumeSizes.Size() == 0)
+  {
+    ::MessageBoxW(*this, LangString(IDS_INCORRECT_VOLUME_SIZE), L"7-Zip", MB_ICONERROR);
+    return;
+  }
+  CModalDialog::OnOK();
+}
diff --git a/CPP/7zip/UI/FileManager/SplitDialog.h b/CPP/7zip/UI/FileManager/SplitDialog.h
new file mode 100644
index 0000000..00aae65
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SplitDialog.h
@@ -0,0 +1,28 @@
+// SplitDialog.h
+
+#ifndef __SPLIT_DIALOG_H
+#define __SPLIT_DIALOG_H
+
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/ComboBox.h"
+
+#include "SplitDialogRes.h"
+
+class CSplitDialog: public NWindows::NControl::CModalDialog
+{
+  NWindows::NControl::CComboBox _pathCombo;
+  NWindows::NControl::CComboBox _volumeCombo;
+  virtual void OnOK();
+  virtual bool OnInit();
+  virtual bool OnSize(WPARAM wParam, int xSize, int ySize);
+  virtual bool OnButtonClicked(int buttonID, HWND buttonHWND);
+  void OnButtonSetPath();
+public:
+  UString FilePath;
+  UString Path;
+  CRecordVector<UInt64> VolumeSizes;
+  INT_PTR Create(HWND parentWindow = 0)
+    { return CModalDialog::Create(IDD_SPLIT, parentWindow); }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/SplitDialog.rc b/CPP/7zip/UI/FileManager/SplitDialog.rc
new file mode 100644
index 0000000..5a026e8
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SplitDialog.rc
@@ -0,0 +1,16 @@
+#include "SplitDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 288
+#define yc 96
+
+IDD_SPLIT  DIALOG  0, 0, xs, ys  MY_MODAL_RESIZE_DIALOG_STYLE  MY_FONT
+CAPTION "Split File"
+BEGIN
+  LTEXT       "&Split to:", IDT_SPLIT_PATH, m, m, xc, 8
+  COMBOBOX    IDC_SPLIT_PATH, m, 20, xc - bxsDots - m, 64, MY_COMBO_WITH_EDIT
+  PUSHBUTTON  "...", IDB_SPLIT_PATH, xs - m - bxsDots, 18, bxsDots, bys, WS_GROUP
+  LTEXT       "Split to &volumes,  bytes:", IDT_SPLIT_VOLUME, m, 44, xc, 8
+  COMBOBOX    IDC_SPLIT_VOLUME, m, 56, 96, 52, MY_COMBO_WITH_EDIT
+  OK_CANCEL
+END
diff --git a/CPP/7zip/UI/FileManager/SplitDialogRes.h b/CPP/7zip/UI/FileManager/SplitDialogRes.h
new file mode 100644
index 0000000..50584a1
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SplitDialogRes.h
@@ -0,0 +1,8 @@
+#define IDD_SPLIT  7300
+
+#define IDT_SPLIT_PATH    7301
+#define IDT_SPLIT_VOLUME  7302
+
+#define IDC_SPLIT_PATH     100
+#define IDB_SPLIT_PATH     101
+#define IDC_SPLIT_VOLUME   102
diff --git a/CPP/7zip/UI/FileManager/SplitUtils.cpp b/CPP/7zip/UI/FileManager/SplitUtils.cpp
new file mode 100644
index 0000000..4b6235b
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SplitUtils.cpp
@@ -0,0 +1,96 @@
+// SplitUtils.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/StringToInt.h"
+
+#include "SplitUtils.h"
+
+bool ParseVolumeSizes(const UString &s, CRecordVector<UInt64> &values)
+{
+  values.Clear();
+  bool prevIsNumber = false;
+  for (unsigned i = 0; i < s.Len();)
+  {
+    wchar_t c = s[i++];
+    if (c == L' ')
+      continue;
+    if (c == L'-')
+      return true;
+    if (prevIsNumber)
+    {
+      prevIsNumber = false;
+      unsigned numBits = 0;
+      switch (MyCharLower_Ascii(c))
+      {
+        case 'b': continue;
+        case 'k': numBits = 10; break;
+        case 'm': numBits = 20; break;
+        case 'g': numBits = 30; break;
+        case 't': numBits = 40; break;
+      }
+      if (numBits != 0)
+      {
+        UInt64 &val = values.Back();
+        if (val >= ((UInt64)1 << (64 - numBits)))
+          return false;
+        val <<= numBits;
+
+        for (; i < s.Len(); i++)
+          if (s[i] == L' ')
+            break;
+        continue;
+      }
+    }
+    i--;
+    const wchar_t *start = s.Ptr(i);
+    const wchar_t *end;
+    UInt64 val = ConvertStringToUInt64(start, &end);
+    if (start == end)
+      return false;
+    if (val == 0)
+      return false;
+    values.Add(val);
+    prevIsNumber = true;
+    i += (unsigned)(end - start);
+  }
+  return true;
+}
+
+
+static const char * const k_Sizes[] =
+{
+    "10M"
+  , "100M"
+  , "1000M"
+  , "650M - CD"
+  , "700M - CD"
+  , "4092M - FAT"
+  , "4480M - DVD"     //  4489 MiB limit
+  , "8128M - DVD DL"  //  8147 MiB limit
+  , "23040M - BD"     // 23866 MiB limit
+  // , "1457664 - 3.5\" floppy"
+};
+
+void AddVolumeItems(NWindows::NControl::CComboBox &combo)
+{
+  for (unsigned i = 0; i < ARRAY_SIZE(k_Sizes); i++)
+    combo.AddString(CSysString(k_Sizes[i]));
+}
+
+UInt64 GetNumberOfVolumes(UInt64 size, const CRecordVector<UInt64> &volSizes)
+{
+  if (size == 0 || volSizes.Size() == 0)
+    return 1;
+  FOR_VECTOR (i, volSizes)
+  {
+    UInt64 volSize = volSizes[i];
+    if (volSize >= size)
+      return i + 1;
+    size -= volSize;
+  }
+  UInt64 volSize = volSizes.Back();
+  if (volSize == 0)
+    return (UInt64)(Int64)-1;
+  return volSizes.Size() + (size - 1) / volSize + 1;
+}
diff --git a/CPP/7zip/UI/FileManager/SplitUtils.h b/CPP/7zip/UI/FileManager/SplitUtils.h
new file mode 100644
index 0000000..641dfe6
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SplitUtils.h
@@ -0,0 +1,15 @@
+// SplitUtils.h
+
+#ifndef __SPLIT_UTILS_H
+#define __SPLIT_UTILS_H
+
+#include "../../../Common/MyTypes.h"
+#include "../../../Common/MyString.h"
+
+#include "../../../Windows/Control/ComboBox.h"
+
+bool ParseVolumeSizes(const UString &s, CRecordVector<UInt64> &values);
+void AddVolumeItems(NWindows::NControl::CComboBox &volumeCombo);
+UInt64 GetNumberOfVolumes(UInt64 size, const CRecordVector<UInt64> &volSizes);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/StdAfx.cpp b/CPP/7zip/UI/FileManager/StdAfx.cpp
new file mode 100644
index 0000000..d0feea8
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/StdAfx.cpp
@@ -0,0 +1,3 @@
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/UI/FileManager/StdAfx.h b/CPP/7zip/UI/FileManager/StdAfx.h
new file mode 100644
index 0000000..0e6d446
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/StdAfx.h
@@ -0,0 +1,21 @@
+// stdafx.h
+
+#ifndef __STDAFX_H
+#define __STDAFX_H
+
+/* we used 0x0400 for Windows NT supporting (MENUITEMINFOW)
+   But now menu problem is fixed. So it's OK to use 0x0500 (Windows 2000) */
+
+// #define _WIN32_WINNT 0x0400
+#define _WIN32_WINNT 0x0500
+#define WINVER _WIN32_WINNT
+
+#include "../../../Common/Common.h"
+
+// #include "../../../Common/MyWindows.h"
+
+// #include <CommCtrl.h>
+// #include <ShlObj.h>
+// #include <Shlwapi.h>
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/StringUtils.cpp b/CPP/7zip/UI/FileManager/StringUtils.cpp
new file mode 100644
index 0000000..0478399
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/StringUtils.cpp
@@ -0,0 +1,65 @@
+// StringUtils.cpp
+
+#include "StdAfx.h"
+
+#include "StringUtils.h"
+
+void SplitStringToTwoStrings(const UString &src, UString &dest1, UString &dest2)
+{
+  dest1.Empty();
+  dest2.Empty();
+  bool quoteMode = false;
+  for (unsigned i = 0; i < src.Len(); i++)
+  {
+    const wchar_t c = src[i];
+    if (c == '\"')
+      quoteMode = !quoteMode;
+    else if (c == ' ' && !quoteMode)
+    {
+      dest2 = src.Ptr(i + 1);
+      return;
+    }
+    else
+      dest1 += c;
+  }
+}
+
+void SplitString(const UString &srcString, UStringVector &destStrings)
+{
+  destStrings.Clear();
+  unsigned len = srcString.Len();
+  if (len == 0)
+    return;
+  UString s;
+  for (unsigned i = 0; i < len; i++)
+  {
+    wchar_t c = srcString[i];
+    if (c == ' ')
+    {
+      if (!s.IsEmpty())
+      {
+        destStrings.Add(s);
+        s.Empty();
+      }
+    }
+    else
+      s += c;
+  }
+  if (!s.IsEmpty())
+    destStrings.Add(s);
+}
+
+/*
+UString JoinStrings(const UStringVector &srcStrings)
+{
+
+  UString s;
+  FOR_VECTOR (i, srcStrings)
+  {
+    if (i != 0)
+      s.Add_Space();
+    s += srcStrings[i];
+  }
+  return s;
+}
+*/
diff --git a/CPP/7zip/UI/FileManager/StringUtils.h b/CPP/7zip/UI/FileManager/StringUtils.h
new file mode 100644
index 0000000..fc070de
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/StringUtils.h
@@ -0,0 +1,13 @@
+// StringUtils.h
+
+#ifndef __STRING_UTILS_H
+#define __STRING_UTILS_H
+
+#include "../../../Common/MyString.h"
+
+void SplitStringToTwoStrings(const UString &src, UString &dest1, UString &dest2);
+
+void SplitString(const UString &srcString, UStringVector &destStrings);
+UString JoinStrings(const UStringVector &srcStrings);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/SysIconUtils.cpp b/CPP/7zip/UI/FileManager/SysIconUtils.cpp
new file mode 100644
index 0000000..b756dfc
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SysIconUtils.cpp
@@ -0,0 +1,255 @@
+// SysIconUtils.cpp
+
+#include "StdAfx.h"
+
+#ifndef _UNICODE
+#include "../../../Common/StringConvert.h"
+#endif
+
+#include "../../../Windows/FileDir.h"
+
+#include "SysIconUtils.h"
+
+#include <ShlObj.h>
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+int GetIconIndexForCSIDL(int csidl)
+{
+  LPITEMIDLIST pidl = 0;
+  SHGetSpecialFolderLocation(NULL, csidl, &pidl);
+  if (pidl)
+  {
+    SHFILEINFO shellInfo;
+    SHGetFileInfo((LPCTSTR)(const void *)(pidl), FILE_ATTRIBUTE_NORMAL,
+      &shellInfo, sizeof(shellInfo),
+      SHGFI_PIDL | SHGFI_SYSICONINDEX);
+    IMalloc  *pMalloc;
+    SHGetMalloc(&pMalloc);
+    if (pMalloc)
+    {
+      pMalloc->Free(pidl);
+      pMalloc->Release();
+    }
+    return shellInfo.iIcon;
+  }
+  return 0;
+}
+
+#ifndef _UNICODE
+typedef int (WINAPI * SHGetFileInfoWP)(LPCWSTR pszPath, DWORD attrib, SHFILEINFOW *psfi, UINT cbFileInfo, UINT uFlags);
+
+static struct CSHGetFileInfoInit
+{
+  SHGetFileInfoWP shGetFileInfoW;
+  CSHGetFileInfoInit()
+  {
+    shGetFileInfoW = (SHGetFileInfoWP)
+    ::GetProcAddress(::GetModuleHandleW(L"shell32.dll"), "SHGetFileInfoW");
+  }
+} g_SHGetFileInfoInit;
+#endif
+
+static DWORD_PTR MySHGetFileInfoW(LPCWSTR pszPath, DWORD attrib, SHFILEINFOW *psfi, UINT cbFileInfo, UINT uFlags)
+{
+  #ifdef _UNICODE
+  return SHGetFileInfo
+  #else
+  if (g_SHGetFileInfoInit.shGetFileInfoW == 0)
+    return 0;
+  return g_SHGetFileInfoInit.shGetFileInfoW
+  #endif
+  (pszPath, attrib, psfi, cbFileInfo, uFlags);
+}
+
+DWORD_PTR GetRealIconIndex(CFSTR path, DWORD attrib, int &iconIndex)
+{
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    SHFILEINFO shellInfo;
+    DWORD_PTR res = ::SHGetFileInfo(fs2fas(path), FILE_ATTRIBUTE_NORMAL | attrib, &shellInfo,
+      sizeof(shellInfo), SHGFI_USEFILEATTRIBUTES | SHGFI_SYSICONINDEX);
+    iconIndex = shellInfo.iIcon;
+    return res;
+  }
+  else
+  #endif
+  {
+    SHFILEINFOW shellInfo;
+    DWORD_PTR res = ::MySHGetFileInfoW(fs2us(path), FILE_ATTRIBUTE_NORMAL | attrib, &shellInfo,
+      sizeof(shellInfo), SHGFI_USEFILEATTRIBUTES | SHGFI_SYSICONINDEX);
+    iconIndex = shellInfo.iIcon;
+    return res;
+  }
+}
+
+/*
+DWORD_PTR GetRealIconIndex(const UString &fileName, DWORD attrib, int &iconIndex, UString *typeName)
+{
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    SHFILEINFO shellInfo;
+    shellInfo.szTypeName[0] = 0;
+    DWORD_PTR res = ::SHGetFileInfoA(GetSystemString(fileName), FILE_ATTRIBUTE_NORMAL | attrib, &shellInfo,
+        sizeof(shellInfo), SHGFI_USEFILEATTRIBUTES | SHGFI_SYSICONINDEX | SHGFI_TYPENAME);
+    if (typeName)
+      *typeName = GetUnicodeString(shellInfo.szTypeName);
+    iconIndex = shellInfo.iIcon;
+    return res;
+  }
+  else
+  #endif
+  {
+    SHFILEINFOW shellInfo;
+    shellInfo.szTypeName[0] = 0;
+    DWORD_PTR res = ::MySHGetFileInfoW(fileName, FILE_ATTRIBUTE_NORMAL | attrib, &shellInfo,
+        sizeof(shellInfo), SHGFI_USEFILEATTRIBUTES | SHGFI_SYSICONINDEX | SHGFI_TYPENAME);
+    if (typeName)
+      *typeName = shellInfo.szTypeName;
+    iconIndex = shellInfo.iIcon;
+    return res;
+  }
+}
+*/
+
+static int FindInSorted_Attrib(const CRecordVector<CAttribIconPair> &vect, DWORD attrib, int &insertPos)
+{
+  unsigned left = 0, right = vect.Size();
+  while (left != right)
+  {
+    unsigned mid = (left + right) / 2;
+    DWORD midAttrib = vect[mid].Attrib;
+    if (attrib == midAttrib)
+      return mid;
+    if (attrib < midAttrib)
+      right = mid;
+    else
+      left = mid + 1;
+  }
+  insertPos = left;
+  return -1;
+}
+
+static int FindInSorted_Ext(const CObjectVector<CExtIconPair> &vect, const wchar_t *ext, int &insertPos)
+{
+  unsigned left = 0, right = vect.Size();
+  while (left != right)
+  {
+    unsigned mid = (left + right) / 2;
+    int compare = MyStringCompareNoCase(ext, vect[mid].Ext);
+    if (compare == 0)
+      return mid;
+    if (compare < 0)
+      right = mid;
+    else
+      left = mid + 1;
+  }
+  insertPos = left;
+  return -1;
+}
+
+int CExtToIconMap::GetIconIndex(DWORD attrib, const wchar_t *fileName /*, UString *typeName */)
+{
+  int dotPos = -1;
+  unsigned i;
+  for (i = 0;; i++)
+  {
+    wchar_t c = fileName[i];
+    if (c == 0)
+      break;
+    if (c == '.')
+      dotPos = i;
+  }
+
+  /*
+  if (MyStringCompareNoCase(fileName, L"$Recycle.Bin") == 0)
+  {
+    char s[256];
+    sprintf(s, "SPEC i = %3d, attr = %7x", _attribMap.Size(), attrib);
+    OutputDebugStringA(s);
+    OutputDebugStringW(fileName);
+  }
+  */
+
+  if ((attrib & FILE_ATTRIBUTE_DIRECTORY) != 0 || dotPos < 0)
+  {
+    int insertPos = 0;
+    int index = FindInSorted_Attrib(_attribMap, attrib, insertPos);
+    if (index >= 0)
+    {
+      // if (typeName) *typeName = _attribMap[index].TypeName;
+      return _attribMap[index].IconIndex;
+    }
+    CAttribIconPair pair;
+    GetRealIconIndex(
+        #ifdef UNDER_CE
+        FTEXT("\\")
+        #endif
+        FTEXT("__DIR__")
+        , attrib, pair.IconIndex
+        // , pair.TypeName
+        );
+
+    /*
+    char s[256];
+    sprintf(s, "i = %3d, attr = %7x", _attribMap.Size(), attrib);
+    OutputDebugStringA(s);
+    */
+
+    pair.Attrib = attrib;
+    _attribMap.Insert(insertPos, pair);
+    // if (typeName) *typeName = pair.TypeName;
+    return pair.IconIndex;
+  }
+
+  const wchar_t *ext = fileName + dotPos + 1;
+  int insertPos = 0;
+  int index = FindInSorted_Ext(_extMap, ext, insertPos);
+  if (index >= 0)
+  {
+    const CExtIconPair &pa = _extMap[index];
+    // if (typeName) *typeName = pa.TypeName;
+    return pa.IconIndex;
+  }
+
+  for (i = 0;; i++)
+  {
+    wchar_t c = ext[i];
+    if (c == 0)
+      break;
+    if (c < L'0' || c > L'9')
+      break;
+  }
+  if (i != 0 && ext[i] == 0)
+  {
+    // GetRealIconIndex is too slow for big number of split extensions: .001, .002, .003
+    if (!SplitIconIndex_Defined)
+    {
+      GetRealIconIndex(
+          #ifdef UNDER_CE
+          FTEXT("\\")
+          #endif
+          FTEXT("__FILE__.001"), 0, SplitIconIndex);
+      SplitIconIndex_Defined = true;
+    }
+    return SplitIconIndex;
+  }
+
+  CExtIconPair pair;
+  pair.Ext = ext;
+  GetRealIconIndex(us2fs(fileName + dotPos), attrib, pair.IconIndex);
+  _extMap.Insert(insertPos, pair);
+  // if (typeName) *typeName = pair.TypeName;
+  return pair.IconIndex;
+}
+
+/*
+int CExtToIconMap::GetIconIndex(DWORD attrib, const UString &fileName)
+{
+  return GetIconIndex(attrib, fileName, NULL);
+}
+*/
diff --git a/CPP/7zip/UI/FileManager/SysIconUtils.h b/CPP/7zip/UI/FileManager/SysIconUtils.h
new file mode 100644
index 0000000..fde16e4
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SysIconUtils.h
@@ -0,0 +1,62 @@
+// SysIconUtils.h
+
+#ifndef __SYS_ICON_UTILS_H
+#define __SYS_ICON_UTILS_H
+
+#include "../../../Common/MyWindows.h"
+
+#include <CommCtrl.h>
+
+#include "../../../Common/MyString.h"
+
+struct CExtIconPair
+{
+  UString Ext;
+  int IconIndex;
+  // UString TypeName;
+
+  // int Compare(const CExtIconPair &a) const { return MyStringCompareNoCase(Ext, a.Ext); }
+};
+
+struct CAttribIconPair
+{
+  DWORD Attrib;
+  int IconIndex;
+  // UString TypeName;
+
+  // int Compare(const CAttribIconPair &a) const { return Ext.Compare(a.Ext); }
+};
+
+class CExtToIconMap
+{
+public:
+  CRecordVector<CAttribIconPair> _attribMap;
+  CObjectVector<CExtIconPair> _extMap;
+  int SplitIconIndex;
+  int SplitIconIndex_Defined;
+  
+  CExtToIconMap(): SplitIconIndex_Defined(false) {}
+
+  void Clear()
+  {
+    SplitIconIndex_Defined = false;
+    _extMap.Clear();
+    _attribMap.Clear();
+  }
+  int GetIconIndex(DWORD attrib, const wchar_t *fileName /* , UString *typeName */);
+  // int GetIconIndex(DWORD attrib, const UString &fileName);
+};
+
+DWORD_PTR GetRealIconIndex(CFSTR path, DWORD attrib, int &iconIndex);
+int GetIconIndexForCSIDL(int csidl);
+
+inline HIMAGELIST GetSysImageList(bool smallIcons)
+{
+  SHFILEINFO shellInfo;
+  return (HIMAGELIST)SHGetFileInfo(TEXT(""),
+      FILE_ATTRIBUTE_NORMAL | FILE_ATTRIBUTE_DIRECTORY,
+      &shellInfo, sizeof(shellInfo),
+      SHGFI_USEFILEATTRIBUTES | SHGFI_SYSICONINDEX | (smallIcons ? SHGFI_SMALLICON : SHGFI_ICON));
+}
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/SystemPage.cpp b/CPP/7zip/UI/FileManager/SystemPage.cpp
new file mode 100644
index 0000000..a95999f
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SystemPage.cpp
@@ -0,0 +1,464 @@
+// SystemPage.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyWindows.h"
+
+#include <ShlObj.h>
+
+#include "../../../Common/Defs.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/ErrorMsg.h"
+
+#include "HelpUtils.h"
+#include "IFolder.h"
+#include "LangUtils.h"
+#include "PropertyNameRes.h"
+#include "SystemPage.h"
+#include "SystemPageRes.h"
+
+using namespace NWindows;
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+static const UInt32 kLangIDs[] =
+{
+  IDT_SYSTEM_ASSOCIATE
+};
+
+#define kSystemTopic "FM/options.htm#system"
+
+CSysString CModifiedExtInfo::GetString() const
+{
+  const char *s;
+  if (State == kExtState_7Zip)
+    s = "7-Zip";
+  else if (State == kExtState_Clear)
+    s = "";
+  else if (Other7Zip)
+    s = "[7-Zip]";
+  else
+    return ProgramKey;
+  return CSysString (s);
+};
+
+
+int CSystemPage::AddIcon(const UString &iconPath, int iconIndex)
+{
+  if (iconPath.IsEmpty())
+    return -1;
+  if (iconIndex == -1)
+    iconIndex = 0;
+  
+  HICON hicon;
+  
+  #ifdef UNDER_CE
+  ExtractIconExW(iconPath, iconIndex, NULL, &hicon, 1);
+  if (!hicon)
+  #else
+  // we expand path from REG_EXPAND_SZ registry item.
+  UString path;
+  DWORD size = MAX_PATH + 10;
+  DWORD needLen = ::ExpandEnvironmentStringsW(iconPath, path.GetBuf(size + 2), size);
+  path.ReleaseBuf_CalcLen(size);
+  if (needLen == 0 || needLen >= size)
+    path = iconPath;
+  int num = ExtractIconExW(path, iconIndex, NULL, &hicon, 1);
+  if (num != 1 || !hicon)
+  #endif
+    return -1;
+  
+  _imageList.AddIcon(hicon);
+  DestroyIcon(hicon);
+  return _numIcons++;
+}
+
+
+void CSystemPage::RefreshListItem(unsigned group, unsigned listIndex)
+{
+  const CAssoc &assoc = _items[GetRealIndex(listIndex)];
+  _listView.SetSubItem(listIndex, group + 1, assoc.Pair[group].GetString());
+  LVITEMW newItem;
+  memset(&newItem, 0, sizeof(newItem));
+  newItem.iItem = listIndex;
+  newItem.mask = LVIF_IMAGE;
+  newItem.iImage = assoc.GetIconIndex();
+  _listView.SetItem(&newItem);
+}
+
+
+void CSystemPage::ChangeState(unsigned group, const CUIntVector &indices)
+{
+  if (indices.IsEmpty())
+    return;
+
+  bool thereAreClearItems = false;
+  unsigned counters[3] = { 0, 0, 0 };
+  
+  unsigned i;
+  for (i = 0; i < indices.Size(); i++)
+  {
+    const CModifiedExtInfo &mi = _items[GetRealIndex(indices[i])].Pair[group];
+    int state = kExtState_7Zip;
+    if (mi.State == kExtState_7Zip)
+      state = kExtState_Clear;
+    else if (mi.State == kExtState_Clear)
+    {
+      thereAreClearItems = true;
+      if (mi.Other)
+        state = kExtState_Other;
+    }
+    counters[state]++;
+  }
+
+  int state = kExtState_Clear;
+  if (counters[kExtState_Other] != 0)
+    state = kExtState_Other;
+  else if (counters[kExtState_7Zip] != 0)
+    state = kExtState_7Zip;
+  
+  for (i = 0; i < indices.Size(); i++)
+  {
+    unsigned listIndex = indices[i];
+    CAssoc &assoc = _items[GetRealIndex(listIndex)];
+    CModifiedExtInfo &mi = assoc.Pair[group];
+    bool change = false;
+    
+    switch (state)
+    {
+      case kExtState_Clear: change = true; break;
+      case kExtState_Other: change = mi.Other; break;
+      default: change = !(mi.Other && thereAreClearItems); break;
+    }
+    
+    if (change)
+    {
+      mi.State = state;
+      RefreshListItem(group, listIndex);
+    }
+  }
+  
+  _needSave = true;
+  Changed();
+}
+
+
+bool CSystemPage::OnInit()
+{
+  _needSave = false;
+
+  LangSetDlgItems(*this, kLangIDs, ARRAY_SIZE(kLangIDs));
+
+  _listView.Attach(GetItem(IDL_SYSTEM_ASSOCIATE));
+  _listView.SetUnicodeFormat();
+  DWORD newFlags = LVS_EX_FULLROWSELECT;
+  _listView.SetExtendedListViewStyle(newFlags, newFlags);
+
+  _numIcons = 0;
+  _imageList.Create(16, 16, ILC_MASK | ILC_COLOR32, 0, 0);
+
+  _listView.SetImageList(_imageList, LVSIL_SMALL);
+
+  _listView.InsertColumn(0, LangString(IDS_PROP_FILE_TYPE), 72);
+
+  UString s;
+
+  #if NUM_EXT_GROUPS == 1
+    s = "Program";
+  #else
+    #ifndef UNDER_CE
+      const unsigned kSize = 256;
+      BOOL res;
+
+      DWORD size = kSize;
+
+      #ifndef _UNICODE
+      if (!g_IsNT)
+      {
+        AString s2;
+        res = GetUserNameA(s2.GetBuf(size), &size);
+        s2.ReleaseBuf_CalcLen(MyMin((unsigned)size, kSize));
+        s = GetUnicodeString(s2);
+      }
+      else
+      #endif
+      {
+        res = GetUserNameW(s.GetBuf(size), &size);
+        s.ReleaseBuf_CalcLen(MyMin((unsigned)size, kSize));
+      }
+    
+      if (!res)
+    #endif
+        s = "Current User";
+  #endif
+
+  LV_COLUMNW ci;
+  ci.mask = LVCF_TEXT | LVCF_FMT | LVCF_WIDTH | LVCF_SUBITEM;
+  ci.cx = 128;
+  ci.fmt = LVCFMT_CENTER;
+  ci.pszText = s.Ptr_non_const();
+  ci.iSubItem = 1;
+  _listView.InsertColumn(1, &ci);
+
+  #if NUM_EXT_GROUPS > 1
+  {
+    LangString(IDS_SYSTEM_ALL_USERS, s);
+    ci.pszText = s.Ptr_non_const();
+    ci.iSubItem = 2;
+    _listView.InsertColumn(2, &ci);
+  }
+  #endif
+
+  _extDB.Read();
+  _items.Clear();
+
+  FOR_VECTOR (i, _extDB.Exts)
+  {
+    const CExtPlugins &extInfo = _extDB.Exts[i];
+
+    LVITEMW item;
+    item.iItem = i;
+    item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
+    item.lParam = i;
+    item.iSubItem = 0;
+    // ListView always uses internal iImage that is 0 by default?
+    // so we always use LVIF_IMAGE.
+    item.iImage = -1;
+    item.pszText = extInfo.Ext.Ptr_non_const();
+
+    CAssoc assoc;
+    const CPluginToIcon &plug = extInfo.Plugins[0];
+    assoc.SevenZipImageIndex = AddIcon(plug.IconPath, plug.IconIndex);
+
+    CSysString texts[NUM_EXT_GROUPS];
+    unsigned g;
+    for (g = 0; g < NUM_EXT_GROUPS; g++)
+    {
+      CModifiedExtInfo &mi = assoc.Pair[g];
+      mi.ReadFromRegistry(GetHKey(g), GetSystemString(extInfo.Ext));
+      mi.SetState(plug.IconPath);
+      mi.ImageIndex = AddIcon(mi.IconPath, mi.IconIndex);
+      texts[g] = mi.GetString();
+    }
+    item.iImage = assoc.GetIconIndex();
+    int itemIndex = _listView.InsertItem(&item);
+    for (g = 0; g < NUM_EXT_GROUPS; g++)
+      _listView.SetSubItem(itemIndex, 1 + g, texts[g]);
+    _items.Add(assoc);
+  }
+  
+  if (_listView.GetItemCount() > 0)
+    _listView.SetItemState(0, LVIS_FOCUSED, LVIS_FOCUSED);
+
+  return CPropertyPage::OnInit();
+}
+
+
+static UString GetProgramCommand()
+{
+  UString s ('\"');
+  s += fs2us(NDLL::GetModuleDirPrefix());
+  s += "7zFM.exe\" \"%1\"";
+  return s;
+}
+
+
+LONG CSystemPage::OnApply()
+{
+  if (!_needSave)
+    return PSNRET_NOERROR;
+
+  const UString command = GetProgramCommand();
+  
+  LONG res = 0;
+
+  FOR_VECTOR (listIndex, _extDB.Exts)
+  {
+    unsigned realIndex = GetRealIndex(listIndex);
+    const CExtPlugins &extInfo = _extDB.Exts[realIndex];
+    CAssoc &assoc = _items[realIndex];
+
+    for (unsigned g = 0; g < NUM_EXT_GROUPS; g++)
+    {
+      CModifiedExtInfo &mi = assoc.Pair[g];
+      HKEY key = GetHKey(g);
+      
+      if (mi.OldState != mi.State)
+      {
+        LONG res2 = 0;
+        
+        if (mi.State == kExtState_7Zip)
+        {
+          UString title = extInfo.Ext;
+          title += " Archive";
+          const CPluginToIcon &plug = extInfo.Plugins[0];
+          res2 = NRegistryAssoc::AddShellExtensionInfo(key, GetSystemString(extInfo.Ext),
+              title, command, plug.IconPath, plug.IconIndex);
+        }
+        else if (mi.State == kExtState_Clear)
+          res2 = NRegistryAssoc::DeleteShellExtensionInfo(key, GetSystemString(extInfo.Ext));
+        
+        if (res == 0)
+          res = res2;
+        if (res2 == 0)
+          mi.OldState = mi.State;
+        
+        mi.State = mi.OldState;
+        RefreshListItem(g, listIndex);
+      }
+    }
+  }
+  
+  #ifndef UNDER_CE
+  SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);
+  #endif
+
+  WasChanged = true;
+
+  _needSave = false;
+  
+  if (res != 0)
+    MessageBoxW(*this, NError::MyFormatMessage(res), L"7-Zip", MB_ICONERROR);
+  
+  return PSNRET_NOERROR;
+}
+
+
+void CSystemPage::OnNotifyHelp()
+{
+  ShowHelpWindow(kSystemTopic);
+}
+
+
+bool CSystemPage::OnButtonClicked(int buttonID, HWND buttonHWND)
+{
+  switch (buttonID)
+  {
+    /*
+    case IDC_SYSTEM_SELECT_ALL:
+      _listView.SelectAll();
+      return true;
+    */
+    case IDB_SYSTEM_CURRENT:
+    case IDB_SYSTEM_ALL:
+      ChangeState(buttonID == IDB_SYSTEM_CURRENT ? 0 : 1);
+      return true;
+  }
+  return CPropertyPage::OnButtonClicked(buttonID, buttonHWND);
+}
+
+
+bool CSystemPage::OnNotify(UINT controlID, LPNMHDR lParam)
+{
+  if (lParam->hwndFrom == HWND(_listView))
+  {
+    switch (lParam->code)
+    {
+      case NM_RETURN:
+      {
+        ChangeState(0);
+        return true;
+      }
+
+      case NM_CLICK:
+      {
+        #ifdef UNDER_CE
+        NMLISTVIEW *item = (NMLISTVIEW *)lParam;
+        #else
+        NMITEMACTIVATE *item = (NMITEMACTIVATE *)lParam;
+        if (item->uKeyFlags == 0)
+        #endif
+        {
+          if (item->iItem >= 0)
+          {
+            // unsigned realIndex = GetRealIndex(item->iItem);
+            if (item->iSubItem >= 1 && item->iSubItem <= 2)
+            {
+              CUIntVector indices;
+              indices.Add(item->iItem);
+              ChangeState(item->iSubItem < 2 ? 0 : 1, indices);
+            }
+          }
+        }
+        break;
+      }
+      
+      case LVN_KEYDOWN:
+      {
+        if (OnListKeyDown(LPNMLVKEYDOWN(lParam)))
+          return true;
+        break;
+      }
+      
+      /*
+      case NM_RCLICK:
+      case NM_DBLCLK:
+      case LVN_BEGINRDRAG:
+        // PostMessage(kRefreshpluginsListMessage, 0);
+        PostMessage(kUpdateDatabase, 0);
+        break;
+      */
+    }
+  }
+  return CPropertyPage::OnNotify(controlID, lParam);
+}
+
+
+void CSystemPage::ChangeState(unsigned group)
+{
+  CUIntVector indices;
+  
+  int itemIndex = -1;
+  while ((itemIndex = _listView.GetNextSelectedItem(itemIndex)) != -1)
+    indices.Add(itemIndex);
+  
+  if (indices.IsEmpty())
+    FOR_VECTOR (i, _items)
+      indices.Add(i);
+  
+  ChangeState(group, indices);
+}
+
+
+bool CSystemPage::OnListKeyDown(LPNMLVKEYDOWN keyDownInfo)
+{
+  bool ctrl = IsKeyDown(VK_CONTROL);
+  bool alt = IsKeyDown(VK_MENU);
+
+  if (alt)
+    return false;
+
+  if ((ctrl && keyDownInfo->wVKey == 'A')
+      || (!ctrl && keyDownInfo->wVKey == VK_MULTIPLY))
+  {
+    _listView.SelectAll();
+    return true;
+  }
+
+  switch (keyDownInfo->wVKey)
+  {
+    case VK_SPACE:
+    case VK_ADD:
+    case VK_SUBTRACT:
+    case VK_SEPARATOR:
+    case VK_DIVIDE:
+
+    #ifndef UNDER_CE
+    case VK_OEM_PLUS:
+    case VK_OEM_MINUS:
+    #endif
+
+      if (!ctrl)
+      {
+        ChangeState(keyDownInfo->wVKey == VK_SPACE ? 0 : 1);
+        return true;
+      }
+      break;
+  }
+
+  return false;
+}
diff --git a/CPP/7zip/UI/FileManager/SystemPage.h b/CPP/7zip/UI/FileManager/SystemPage.h
new file mode 100644
index 0000000..765214c
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SystemPage.h
@@ -0,0 +1,126 @@
+// SystemPage.h
+ 
+#ifndef __SYSTEM_PAGE_H
+#define __SYSTEM_PAGE_H
+
+#include "../../../Windows/Control/ImageList.h"
+#include "../../../Windows/Control/ListView.h"
+#include "../../../Windows/Control/PropertyPage.h"
+
+#include "FilePlugins.h"
+#include "RegistryAssociations.h"
+
+enum EExtState
+{
+  kExtState_Clear = 0,
+  kExtState_Other,
+  kExtState_7Zip
+};
+
+struct CModifiedExtInfo: public NRegistryAssoc::CShellExtInfo
+{
+  int OldState;
+  int State;
+  int ImageIndex;
+  bool Other;
+  bool Other7Zip;
+
+  CModifiedExtInfo(): ImageIndex(-1) {}
+
+  CSysString GetString() const;
+
+  void SetState(const UString &iconPath)
+  {
+    State = kExtState_Clear;
+    Other = false;
+    Other7Zip = false;
+    if (!ProgramKey.IsEmpty())
+    {
+      State = kExtState_Other;
+      Other = true;
+      if (IsIt7Zip())
+      {
+        Other7Zip = !iconPath.IsEqualTo_NoCase(IconPath);
+        if (!Other7Zip)
+        {
+          State = kExtState_7Zip;
+          Other = false;
+        }
+      }
+    }
+    OldState = State;
+  };
+};
+
+struct CAssoc
+{
+  CModifiedExtInfo Pair[2];
+  int SevenZipImageIndex;
+
+  int GetIconIndex() const
+  {
+    for (unsigned i = 0; i < 2; i++)
+    {
+      const CModifiedExtInfo &pair = Pair[i];
+      if (pair.State == kExtState_Clear)
+        continue;
+      if (pair.State == kExtState_7Zip)
+        return SevenZipImageIndex;
+      if (pair.ImageIndex != -1)
+        return pair.ImageIndex;
+    }
+    return -1;
+  }
+};
+
+#ifdef UNDER_CE
+  #define NUM_EXT_GROUPS 1
+#else
+  #define NUM_EXT_GROUPS 2
+#endif
+
+class CSystemPage: public NWindows::NControl::CPropertyPage
+{
+  CExtDatabase _extDB;
+  CObjectVector<CAssoc> _items;
+
+  unsigned _numIcons;
+  NWindows::NControl::CImageList _imageList;
+  NWindows::NControl::CListView _listView;
+
+  bool _needSave;
+
+  HKEY GetHKey(unsigned
+      #if NUM_EXT_GROUPS != 1
+        group
+      #endif
+      ) const
+  {
+    #if NUM_EXT_GROUPS == 1
+      return HKEY_CLASSES_ROOT;
+    #else
+      return group == 0 ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE;
+    #endif
+  }
+
+  int AddIcon(const UString &path, int iconIndex);
+  unsigned GetRealIndex(unsigned listIndex) const { return listIndex; }
+  void RefreshListItem(unsigned group, unsigned listIndex);
+  void ChangeState(unsigned group, const CUIntVector &indices);
+  void ChangeState(unsigned group);
+
+  bool OnListKeyDown(LPNMLVKEYDOWN keyDownInfo);
+  
+public:
+  bool WasChanged;
+  
+  CSystemPage(): WasChanged(false) {}
+
+  virtual bool OnInit();
+  virtual void OnNotifyHelp();
+  virtual bool OnNotify(UINT controlID, LPNMHDR lParam);
+  virtual LONG OnApply();
+  virtual bool OnButtonClicked(int buttonID, HWND buttonHWND);
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/SystemPage.rc b/CPP/7zip/UI/FileManager/SystemPage.rc
new file mode 100644
index 0000000..3bb143a
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SystemPage.rc
@@ -0,0 +1,43 @@
+#include "SystemPageRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 240
+#define yc 252
+
+IDD_SYSTEM  DIALOG  0, 0, xs, ys  MY_PAGE_STYLE  MY_FONT
+CAPTION "System"
+BEGIN
+  LTEXT       "Associate 7-Zip with:", IDT_SYSTEM_ASSOCIATE, m, m, xc, 8
+  PUSHBUTTON  "+", IDB_SYSTEM_CURRENT, 80, m + 12, 40, bys
+  PUSHBUTTON  "+", IDB_SYSTEM_ALL,    166, m + 12, 40, bys
+  CONTROL     "List1", IDL_SYSTEM_ASSOCIATE, "SysListView32",
+              LVS_REPORT | LVS_SHOWSELALWAYS | LVS_SHAREIMAGELISTS | LVS_NOSORTHEADER | WS_BORDER | WS_TABSTOP,
+              m, m + 32, xc, (yc - 32)
+END
+
+#ifdef UNDER_CE
+
+#undef m
+#undef xc
+#undef yc
+
+#define m 4
+#define xc (SMALL_PAGE_SIZE_X + 8)
+#define yc (128 + 8)
+
+IDD_SYSTEM_2  DIALOG  0, 0, xs, ys  MY_PAGE_STYLE  MY_FONT
+CAPTION "System"
+BEGIN
+  LTEXT       "Associate 7-Zip with:", IDT_SYSTEM_ASSOCIATE, m, m, xc, 8
+  PUSHBUTTON  "+", IDB_SYSTEM_CURRENT, 60, m + 12, 40, bys
+  CONTROL     "List1", IDL_SYSTEM_ASSOCIATE, "SysListView32",
+              LVS_REPORT | LVS_SHOWSELALWAYS | LVS_SHAREIMAGELISTS | LVS_NOSORTHEADER | WS_BORDER | WS_TABSTOP,
+              m, m + 32, xc, (yc - 32)
+END
+
+#endif
+
+STRINGTABLE
+BEGIN
+  IDS_SYSTEM_ALL_USERS  "All users"
+END
diff --git a/CPP/7zip/UI/FileManager/SystemPageRes.h b/CPP/7zip/UI/FileManager/SystemPageRes.h
new file mode 100644
index 0000000..c894448
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SystemPageRes.h
@@ -0,0 +1,9 @@
+#define IDD_SYSTEM     2200
+#define IDD_SYSTEM_2  12200
+
+#define IDT_SYSTEM_ASSOCIATE  2201
+#define IDS_SYSTEM_ALL_USERS  2202
+
+#define IDL_SYSTEM_ASSOCIATE   100
+#define IDB_SYSTEM_CURRENT     101
+#define IDB_SYSTEM_ALL         102
diff --git a/CPP/7zip/UI/FileManager/Test.bmp b/CPP/7zip/UI/FileManager/Test.bmp
new file mode 100644
index 0000000..ef85ba2
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Test.bmp
diff --git a/CPP/7zip/UI/FileManager/Test2.bmp b/CPP/7zip/UI/FileManager/Test2.bmp
new file mode 100644
index 0000000..99b7dbf
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Test2.bmp
diff --git a/CPP/7zip/UI/FileManager/TextPairs.cpp b/CPP/7zip/UI/FileManager/TextPairs.cpp
new file mode 100644
index 0000000..6a989fc
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/TextPairs.cpp
@@ -0,0 +1,190 @@
+// TextPairs.cpp
+
+#include "StdAfx.h"
+
+#include "TextPairs.h"
+
+static const wchar_t kNewLineChar = '\n';
+static const wchar_t kQuoteChar = '\"';
+
+static const wchar_t kBOM = (wchar_t)0xFEFF;
+
+static bool IsSeparatorChar(wchar_t c)
+{
+  return (c == ' ' || c == '\t');
+}
+
+static void RemoveCr(UString &s)
+{
+  s.RemoveChar(L'\x0D');
+}
+
+static UString GetIDString(const wchar_t *srcString, unsigned &finishPos)
+{
+  UString result;
+  bool quotes = false;
+  for (finishPos = 0;;)
+  {
+    wchar_t c = srcString[finishPos];
+    if (c == 0)
+      break;
+    finishPos++;
+    bool isSeparatorChar = IsSeparatorChar(c);
+    if (c == kNewLineChar || (isSeparatorChar && !quotes)
+        || (c == kQuoteChar && quotes))
+      break;
+    else if (c == kQuoteChar)
+      quotes = true;
+    else
+      result += c;
+  }
+  result.Trim();
+  RemoveCr(result);
+  return result;
+}
+
+static UString GetValueString(const wchar_t *srcString, unsigned &finishPos)
+{
+  UString result;
+  for (finishPos = 0;;)
+  {
+    wchar_t c = srcString[finishPos];
+    if (c == 0)
+      break;
+    finishPos++;
+    if (c == kNewLineChar)
+      break;
+    result += c;
+  }
+  result.Trim();
+  RemoveCr(result);
+  return result;
+}
+
+static bool GetTextPairs(const UString &srcString, CObjectVector<CTextPair> &pairs)
+{
+  pairs.Clear();
+  unsigned pos = 0;
+  
+  if (srcString.Len() > 0)
+  {
+    if (srcString[0] == kBOM)
+      pos++;
+  }
+  while (pos < srcString.Len())
+  {
+    unsigned finishPos;
+    UString id = GetIDString((const wchar_t *)srcString + pos, finishPos);
+    pos += finishPos;
+    if (id.IsEmpty())
+      continue;
+    UString value = GetValueString((const wchar_t *)srcString + pos, finishPos);
+    pos += finishPos;
+    if (!id.IsEmpty())
+    {
+      CTextPair pair;
+      pair.ID = id;
+      pair.Value = value;
+      pairs.Add(pair);
+    }
+  }
+  return true;
+}
+
+static int ComparePairIDs(const UString &s1, const UString &s2)
+  { return MyStringCompareNoCase(s1, s2); }
+
+static int ComparePairItems(const CTextPair &p1, const CTextPair &p2)
+  { return ComparePairIDs(p1.ID, p2.ID); }
+
+static int ComparePairItems(void *const *a1, void *const *a2, void * /* param */)
+  { return ComparePairItems(**(const CTextPair *const *)a1, **(const CTextPair *const *)a2); }
+
+void CPairsStorage::Sort() { Pairs.Sort(ComparePairItems, 0); }
+
+int CPairsStorage::FindID(const UString &id, int &insertPos) const
+{
+  int left = 0, right = Pairs.Size();
+  while (left != right)
+  {
+    int mid = (left + right) / 2;
+    int compResult = ComparePairIDs(id, Pairs[mid].ID);
+    if (compResult == 0)
+      return mid;
+    if (compResult < 0)
+      right = mid;
+    else
+      left = mid + 1;
+  }
+  insertPos = left;
+  return -1;
+}
+
+int CPairsStorage::FindID(const UString &id) const
+{
+  int pos;
+  return FindID(id, pos);
+}
+
+void CPairsStorage::AddPair(const CTextPair &pair)
+{
+  int insertPos;
+  int pos = FindID(pair.ID, insertPos);
+  if (pos >= 0)
+    Pairs[pos] = pair;
+  else
+    Pairs.Insert(insertPos, pair);
+}
+
+void CPairsStorage::DeletePair(const UString &id)
+{
+  int pos = FindID(id);
+  if (pos >= 0)
+    Pairs.Delete(pos);
+}
+
+bool CPairsStorage::GetValue(const UString &id, UString &value) const
+{
+  value.Empty();
+  int pos = FindID(id);
+  if (pos < 0)
+    return false;
+  value = Pairs[pos].Value;
+  return true;
+}
+
+UString CPairsStorage::GetValue(const UString &id) const
+{
+  int pos = FindID(id);
+  if (pos < 0)
+    return UString();
+  return Pairs[pos].Value;
+}
+
+bool CPairsStorage::ReadFromString(const UString &text)
+{
+  bool result = ::GetTextPairs(text, Pairs);
+  if (result)
+    Sort();
+  else
+    Pairs.Clear();
+  return result;
+}
+
+void CPairsStorage::SaveToString(UString &text) const
+{
+  FOR_VECTOR (i, Pairs)
+  {
+    const CTextPair &pair = Pairs[i];
+    bool multiWord = (pair.ID.Find(L' ') >= 0);
+    if (multiWord)
+      text += '\"';
+    text += pair.ID;
+    if (multiWord)
+      text += '\"';
+    text += ' ';
+    text += pair.Value;
+    text += '\x0D';
+    text.Add_LF();
+  }
+}
diff --git a/CPP/7zip/UI/FileManager/TextPairs.h b/CPP/7zip/UI/FileManager/TextPairs.h
new file mode 100644
index 0000000..0a71d04
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/TextPairs.h
@@ -0,0 +1,32 @@
+// TextPairs.h
+
+#ifndef __FM_TEXT_PAIRS_H
+#define __FM_TEXT_PAIRS_H
+
+#include "../../../Common/MyString.h"
+
+struct CTextPair
+{
+  UString ID;
+  UString Value;
+};
+
+class CPairsStorage
+{
+  CObjectVector<CTextPair> Pairs;
+  
+  int FindID(const UString &id, int &insertPos) const;
+  int FindID(const UString &id) const;
+  void Sort();
+public:
+  void Clear() { Pairs.Clear(); }
+  bool ReadFromString(const UString &text);
+  void SaveToString(UString &text) const;
+
+  bool GetValue(const UString &id, UString &value) const;
+  UString GetValue(const UString &id) const;
+  void AddPair(const CTextPair &pair);
+  void DeletePair(const UString &id);
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/UpdateCallback100.cpp b/CPP/7zip/UI/FileManager/UpdateCallback100.cpp
new file mode 100644
index 0000000..67e70fb
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/UpdateCallback100.cpp
@@ -0,0 +1,124 @@
+// UpdateCallback100.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/ErrorMsg.h"
+
+#include "../GUI/resource3.h"
+
+#include "LangUtils.h"
+#include "UpdateCallback100.h"
+
+STDMETHODIMP CUpdateCallback100Imp::ScanProgress(UInt64 /* numFolders */, UInt64 numFiles, UInt64 totalSize, const wchar_t *path, Int32 /* isDir */)
+{
+  return ProgressDialog->Sync.ScanProgress(numFiles, totalSize, us2fs(path));
+}
+
+STDMETHODIMP CUpdateCallback100Imp::ScanError(const wchar_t *path, HRESULT errorCode)
+{
+  ProgressDialog->Sync.AddError_Code_Name(errorCode, path);
+  return S_OK;
+}
+
+STDMETHODIMP CUpdateCallback100Imp::SetNumFiles(UInt64 numFiles)
+{
+  return ProgressDialog->Sync.Set_NumFilesTotal(numFiles);
+}
+
+STDMETHODIMP CUpdateCallback100Imp::SetTotal(UInt64 size)
+{
+  ProgressDialog->Sync.Set_NumBytesTotal(size);
+  return S_OK;
+}
+
+STDMETHODIMP CUpdateCallback100Imp::SetCompleted(const UInt64 *completed)
+{
+  return ProgressDialog->Sync.Set_NumBytesCur(completed);
+}
+
+STDMETHODIMP CUpdateCallback100Imp::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize)
+{
+  ProgressDialog->Sync.Set_Ratio(inSize, outSize);
+  return S_OK;
+}
+
+STDMETHODIMP CUpdateCallback100Imp::CompressOperation(const wchar_t *name)
+{
+  return SetOperation_Base(NUpdateNotifyOp::kAdd, name, false);
+}
+
+STDMETHODIMP CUpdateCallback100Imp::DeleteOperation(const wchar_t *name)
+{
+  return SetOperation_Base(NUpdateNotifyOp::kDelete, name, false);
+}
+
+STDMETHODIMP CUpdateCallback100Imp::OperationResult(Int32 /* operationResult */)
+{
+  ProgressDialog->Sync.Set_NumFilesCur(++NumFiles);
+  return S_OK;
+}
+
+void SetExtractErrorMessage(Int32 opRes, Int32 encrypted, const wchar_t *fileName, UString &s);
+
+HRESULT CUpdateCallback100Imp::ReportExtractResult(Int32 opRes, Int32 isEncrypted, const wchar_t *name)
+{
+  if (opRes != NArchive::NExtract::NOperationResult::kOK)
+  {
+    UString s;
+    SetExtractErrorMessage(opRes, isEncrypted, name, s);
+    ProgressDialog->Sync.AddError_Message(s);
+  }
+  return S_OK;
+}
+
+HRESULT CUpdateCallback100Imp::ReportUpdateOperation(UInt32 notifyOp, const wchar_t *name, Int32 isDir)
+{
+  return SetOperation_Base(notifyOp, name, IntToBool(isDir));
+}
+
+STDMETHODIMP CUpdateCallback100Imp::UpdateErrorMessage(const wchar_t *message)
+{
+  ProgressDialog->Sync.AddError_Message(message);
+  return S_OK;
+}
+
+HRESULT CUpdateCallback100Imp::OpenFileError(const wchar_t *path, HRESULT errorCode)
+{
+  ProgressDialog->Sync.AddError_Code_Name(errorCode, path);
+  return S_OK;
+}
+
+STDMETHODIMP CUpdateCallback100Imp::ReadingFileError(const wchar_t *path, HRESULT errorCode)
+{
+  ProgressDialog->Sync.AddError_Code_Name(errorCode, path);
+  return S_OK;
+}
+
+STDMETHODIMP CUpdateCallback100Imp::CryptoGetTextPassword2(Int32 *passwordIsDefined, BSTR *password)
+{
+  *password = NULL;
+  *passwordIsDefined = BoolToInt(PasswordIsDefined);
+  if (!PasswordIsDefined)
+    return S_OK;
+  return StringToBstr(Password, password);
+}
+
+STDMETHODIMP CUpdateCallback100Imp::SetTotal(const UInt64 * /* files */, const UInt64 * /* bytes */)
+{
+  return S_OK;
+}
+
+STDMETHODIMP CUpdateCallback100Imp::SetCompleted(const UInt64 * /* files */, const UInt64 * /* bytes */)
+{
+  return ProgressDialog->Sync.CheckStop();
+}
+
+STDMETHODIMP CUpdateCallback100Imp::CryptoGetTextPassword(BSTR *password)
+{
+  *password = NULL;
+  if (!PasswordIsDefined)
+  {
+    RINOK(ShowAskPasswordDialog())
+  }
+  return StringToBstr(Password, password);
+}
diff --git a/CPP/7zip/UI/FileManager/UpdateCallback100.h b/CPP/7zip/UI/FileManager/UpdateCallback100.h
new file mode 100644
index 0000000..7cbc11e
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/UpdateCallback100.h
@@ -0,0 +1,52 @@
+// UpdateCallback100.h
+
+#ifndef __UPDATE_CALLBACK100_H
+#define __UPDATE_CALLBACK100_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../IPassword.h"
+
+#include "../Agent/IFolderArchive.h"
+
+#include "../GUI/UpdateCallbackGUI2.h"
+
+#include "ProgressDialog2.h"
+
+class CUpdateCallback100Imp:
+  public IFolderArchiveUpdateCallback,
+  public IFolderArchiveUpdateCallback2,
+  public IFolderScanProgress,
+  public ICryptoGetTextPassword2,
+  public ICryptoGetTextPassword,
+  public IArchiveOpenCallback,
+  public ICompressProgressInfo,
+  public CUpdateCallbackGUI2,
+  public CMyUnknownImp
+{
+public:
+
+  // CUpdateCallback100Imp() {}
+
+  MY_UNKNOWN_IMP7(
+    IFolderArchiveUpdateCallback,
+    IFolderArchiveUpdateCallback2,
+    IFolderScanProgress,
+    ICryptoGetTextPassword2,
+    ICryptoGetTextPassword,
+    IArchiveOpenCallback,
+    ICompressProgressInfo)
+
+  INTERFACE_IProgress(;)
+  INTERFACE_IArchiveOpenCallback(;)
+  INTERFACE_IFolderArchiveUpdateCallback(;)
+  INTERFACE_IFolderArchiveUpdateCallback2(;)
+  INTERFACE_IFolderScanProgress(;)
+
+  STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
+
+  STDMETHOD(CryptoGetTextPassword)(BSTR *password);
+  STDMETHOD(CryptoGetTextPassword2)(Int32 *passwordIsDefined, BSTR *password);
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/VerCtrl.cpp b/CPP/7zip/UI/FileManager/VerCtrl.cpp
new file mode 100644
index 0000000..4bb034f
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/VerCtrl.cpp
@@ -0,0 +1,428 @@
+// VerCtrl.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/StringToInt.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/FileFind.h"
+
+#include "App.h"
+#include "RegistryUtils.h"
+#include "OverwriteDialog.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NFind;
+using namespace NDir;
+
+static FString ConvertPath_to_Ctrl(const FString &path)
+{
+  FString s = path;
+  s.Replace(FChar(':'), FChar('_'));
+  return s;
+}
+
+struct CFileDataInfo
+{
+  CByteBuffer Data;
+  BY_HANDLE_FILE_INFORMATION Info;
+  bool IsOpen;
+
+  CFileDataInfo(): IsOpen (false) {}
+  UInt64 GetSize() const { return (((UInt64)Info.nFileSizeHigh) << 32) + Info.nFileSizeLow; }
+  bool Read(const FString &path);
+};
+
+
+bool CFileDataInfo::Read(const FString &path)
+{
+  IsOpen = false;
+  NIO::CInFile file;
+  if (!file.Open(path))
+    return false;
+  if (!file.GetFileInformation(&Info))
+    return false;
+
+  const UInt64 size = GetSize();
+  const size_t size2 = (size_t)size;
+  if (size2 != size || size2 > (1 << 28))
+  {
+    SetLastError(1);
+    return false;
+  }
+
+  Data.Alloc(size2);
+
+  size_t processedSize;
+  if (!file.ReadFull(Data, size2, processedSize))
+    return false;
+  if (processedSize != size2)
+  {
+    SetLastError(1);
+    return false;
+  }
+  IsOpen = true;
+  return true;
+}
+
+
+static bool CreateComplexDir_for_File(const FString &path)
+{
+  FString resDirPrefix;
+  FString resFileName;
+  if (!GetFullPathAndSplit(path, resDirPrefix, resFileName))
+    return false;
+  return CreateComplexDir(resDirPrefix);
+}
+
+
+static bool ParseNumberString(const FString &s, UInt32 &number)
+{
+  const FChar *end;
+  UInt64 result = ConvertStringToUInt64(s, &end);
+  if (*end != 0 || s.IsEmpty() || result > (UInt32)0x7FFFFFFF)
+    return false;
+  number = (UInt32)result;
+  return true;
+}
+
+
+static void WriteFile(const FString &path, bool createAlways, const CFileDataInfo &fdi, const CPanel &panel)
+{
+  NIO::COutFile outFile;
+  if (!outFile.Create(path, createAlways)) // (createAlways = false) means CREATE_NEW
+  {
+    panel.MessageBox_LastError();
+    return;
+  }
+  UInt32 processedSize;
+  if (!outFile.Write(fdi.Data, (UInt32)fdi.Data.Size(), processedSize))
+  {
+    panel.MessageBox_LastError();
+    return;
+  }
+  if (processedSize != fdi.Data.Size())
+  {
+    panel.MessageBox_Error(L"Write error");
+    return;
+  }
+  if (!outFile.SetTime(
+      &fdi.Info.ftCreationTime,
+      &fdi.Info.ftLastAccessTime,
+      &fdi.Info.ftLastWriteTime))
+  {
+    panel.MessageBox_LastError();
+    return;
+  }
+
+  if (!SetFileAttrib(path, fdi.Info.dwFileAttributes))
+  {
+    panel.MessageBox_LastError();
+    return;
+  }
+}
+
+
+static UInt64 FILETIME_to_UInt64(const FILETIME &ft)
+{
+  return ft.dwLowDateTime | ((UInt64)ft.dwHighDateTime << 32);
+}
+
+static void UInt64_TO_FILETIME(UInt64 v, FILETIME &ft)
+{
+  ft.dwLowDateTime = (DWORD)v;
+  ft.dwHighDateTime = (DWORD)(v >> 32);
+}
+
+
+void CApp::VerCtrl(unsigned id)
+{
+  const CPanel &panel = GetFocusedPanel();
+  
+  if (!panel.Is_IO_FS_Folder())
+  {
+    panel.MessageBox_Error_UnsupportOperation();
+    return;
+  }
+
+  CRecordVector<UInt32> indices;
+  panel.GetSelectedItemsIndices(indices);
+
+  if (indices.Size() != 1)
+  {
+    // panel.MessageBox_Error_UnsupportOperation();
+    return;
+  }
+
+  const FString path = us2fs(panel.GetItemFullPath(indices[0]));
+
+  UString vercPath;
+  ReadReg_VerCtrlPath(vercPath);
+  if (vercPath.IsEmpty())
+    return;
+  NName::NormalizeDirPathPrefix(vercPath);
+
+  FString dirPrefix;
+  FString fileName;
+  if (!GetFullPathAndSplit(path, dirPrefix, fileName))
+  {
+    panel.MessageBox_LastError();
+    return;
+  }
+
+  const FString dirPrefix2 = us2fs(vercPath) + ConvertPath_to_Ctrl(dirPrefix);
+  const FString path2 = dirPrefix2 + fileName;
+
+  bool sameTime = false;
+  bool sameData = false;
+  bool areIdentical = false;
+
+  CFileDataInfo fdi, fdi2;
+  if (!fdi.Read(path))
+  {
+    panel.MessageBox_LastError();
+    return;
+  }
+
+  if (fdi2.Read(path2))
+  {
+    sameData = (fdi.Data == fdi2.Data);
+    sameTime = (CompareFileTime(&fdi.Info.ftLastWriteTime, &fdi2.Info.ftLastWriteTime) == 0);
+    areIdentical = (sameData && sameTime);
+  }
+
+  const bool isReadOnly = NAttributes::IsReadOnly(fdi.Info.dwFileAttributes);
+
+  if (id == IDM_VER_EDIT)
+  {
+    if (!isReadOnly)
+    {
+      panel.MessageBox_Error(L"File is not read-only");
+      return;
+    }
+    
+    if (!areIdentical)
+    {
+      if (fdi2.IsOpen)
+      {
+        NFind::CEnumerator enumerator;
+        FString d2 = dirPrefix2;
+        d2 += "_7vc";
+        d2.Add_PathSepar();
+        d2 += fileName;
+        d2.Add_PathSepar();
+        enumerator.SetDirPrefix(d2);
+        NFind::CDirEntry fi;
+        Int32 maxVal = -1;
+        while (enumerator.Next(fi))
+        {
+          UInt32 val;
+          if (!ParseNumberString(fi.Name, val))
+            continue;
+          if ((Int32)val > maxVal)
+            maxVal = val;
+        }
+
+        UInt32 next = (UInt32)maxVal + 1;
+        if (maxVal < 0)
+        {
+          next = 1;
+          if (!::CreateComplexDir_for_File(path2))
+          {
+            panel.MessageBox_LastError();
+            return;
+          }
+        }
+
+        // we rename old file2 to some name;
+        FString path_num = d2;
+        {
+          AString t;
+          t.Add_UInt32((UInt32)next);
+          while (t.Len() < 3)
+            t.InsertAtFront('0');
+          path_num += t;
+        }
+
+        if (maxVal < 0)
+        {
+          if (!::CreateComplexDir_for_File(path_num))
+          {
+            panel.MessageBox_LastError();
+            return;
+          }
+        }
+
+        if (!NDir::MyMoveFile(path2, path_num))
+        {
+          panel.MessageBox_LastError();
+          return;
+        }
+      }
+      else
+      {
+        if (!::CreateComplexDir_for_File(path2))
+        {
+          panel.MessageBox_LastError();
+          return;
+        }
+      }
+      /*
+      if (!::CopyFile(fs2fas(path), fs2fas(path2), TRUE))
+      {
+        panel.MessageBox_LastError();
+        return;
+      }
+      */
+      WriteFile(path2,
+          false,  // (createAlways = false) means CREATE_NEW
+          fdi, panel);
+    }
+      
+    if (!SetFileAttrib(path, fdi.Info.dwFileAttributes & ~(DWORD)FILE_ATTRIBUTE_READONLY))
+    {
+      panel.MessageBox_LastError();
+      return;
+    }
+
+    return;
+  }
+  
+  if (isReadOnly)
+  {
+    panel.MessageBox_Error(L"File is read-only");
+    return;
+  }
+
+  if (id == IDM_VER_COMMIT)
+  {
+    if (sameData)
+    {
+      if (!sameTime)
+      {
+        panel.MessageBox_Error(
+          L"Same data, but different timestamps.\n"
+          L"Use `Revert` to recover timestamp.");
+        return;
+      }
+    }
+
+    const UInt64 timeStampOriginal = FILETIME_to_UInt64(fdi.Info.ftLastWriteTime);
+    UInt64 timeStamp2 = 0;
+    if (fdi2.IsOpen)
+      timeStamp2 = FILETIME_to_UInt64(fdi2.Info.ftLastWriteTime);
+
+    if (timeStampOriginal > timeStamp2)
+    {
+      const UInt64 k_Ntfs_prec = 10000000;
+      UInt64 timeStamp = timeStampOriginal;
+      const UInt32 k_precs[] = { 60 * 60, 60, 2, 1 };
+      for (unsigned i = 0; i < ARRAY_SIZE(k_precs); i++)
+      {
+        timeStamp = timeStampOriginal;
+        const UInt64 prec = k_Ntfs_prec * k_precs[i];
+        // timeStamp += prec - 1; // for rounding up
+        timeStamp /= prec;
+        timeStamp *= prec;
+        if (timeStamp > timeStamp2)
+          break;
+      }
+
+      if (timeStamp != timeStampOriginal
+          && timeStamp > timeStamp2)
+      {
+        FILETIME mTime;
+        UInt64_TO_FILETIME(timeStamp, mTime);
+        // NDir::SetFileAttrib(path, 0);
+        {
+          NIO::COutFile outFile;
+          if (!outFile.Open(path, OPEN_EXISTING))
+          {
+            panel.MessageBox_LastError();
+            return;
+            // if (::GetLastError() != ERROR_SUCCESS)
+            // throw "open error";
+          }
+          else
+          {
+            const UInt64 cTime = FILETIME_to_UInt64(fdi.Info.ftCreationTime);
+            if (cTime > timeStamp)
+              outFile.SetTime(&mTime, NULL, &mTime);
+            else
+              outFile.SetMTime(&mTime);
+          }
+        }
+      }
+    }
+
+    if (!SetFileAttrib(path, fdi.Info.dwFileAttributes | FILE_ATTRIBUTE_READONLY))
+    {
+      panel.MessageBox_LastError();
+      return;
+    }
+    return;
+  }
+
+  if (id == IDM_VER_REVERT)
+  {
+    if (!fdi2.IsOpen)
+    {
+      panel.MessageBox_Error(L"No file to revert");
+      return;
+    }
+    if (!sameData || !sameTime)
+    {
+      if (!sameData)
+      {
+        /*
+        UString m;
+        m = "Are you sure you want to revert file ?";
+        m.Add_LF();
+        m += path;
+        if (::MessageBoxW(panel.GetParent(), m, L"Version Control: File Revert", MB_OKCANCEL | MB_ICONQUESTION) != IDOK)
+          return;
+        */
+        COverwriteDialog dialog;
+        
+        dialog.OldFileInfo.SetTime(&fdi.Info.ftLastWriteTime);
+        dialog.OldFileInfo.SetSize(fdi.GetSize());
+        dialog.OldFileInfo.Name = fs2us(path);
+        
+        dialog.NewFileInfo.SetTime(&fdi2.Info.ftLastWriteTime);
+        dialog.NewFileInfo.SetSize(fdi2.GetSize());
+        dialog.NewFileInfo.Name = fs2us(path2);
+
+        dialog.ShowExtraButtons = false;
+        dialog.DefaultButton_is_NO = true;
+        
+        INT_PTR writeAnswer = dialog.Create(panel.GetParent());
+        
+        if (writeAnswer != IDYES)
+          return;
+      }
+      
+      WriteFile(path,
+          true,  // (createAlways = true) means CREATE_ALWAYS
+          fdi2, panel);
+    }
+    else
+    {
+      if (!SetFileAttrib(path, fdi2.Info.dwFileAttributes | FILE_ATTRIBUTE_READONLY))
+      {
+        panel.MessageBox_LastError();
+        return;
+      }
+    }
+    return;
+  }
+
+  // if (id == IDM_VER_DIFF)
+  {
+    if (!fdi2.IsOpen)
+      return;
+    DiffFiles(fs2us(path2), fs2us(path));
+  }
+}
diff --git a/CPP/7zip/UI/FileManager/ViewSettings.cpp b/CPP/7zip/UI/FileManager/ViewSettings.cpp
new file mode 100644
index 0000000..0f87711
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ViewSettings.cpp
@@ -0,0 +1,313 @@
+// ViewSettings.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+ 
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/Registry.h"
+#include "../../../Windows/Synchronization.h"
+
+#include "ViewSettings.h"
+
+using namespace NWindows;
+using namespace NRegistry;
+
+#define REG_PATH_FM TEXT("Software") TEXT(STRING_PATH_SEPARATOR) TEXT("7-Zip") TEXT(STRING_PATH_SEPARATOR) TEXT("FM")
+
+static LPCTSTR const kCUBasePath = REG_PATH_FM;
+static LPCTSTR const kCulumnsKeyName = REG_PATH_FM TEXT(STRING_PATH_SEPARATOR) TEXT("Columns");
+
+static LPCTSTR const kPositionValueName = TEXT("Position");
+static LPCTSTR const kPanelsInfoValueName = TEXT("Panels");
+static LPCTSTR const kToolbars = TEXT("Toolbars");
+
+static LPCWSTR const kPanelPathValueName = L"PanelPath";
+
+static LPCTSTR const kListMode = TEXT("ListMode");
+static LPCTSTR const kFolderHistoryValueName = TEXT("FolderHistory");
+static LPCTSTR const kFastFoldersValueName = TEXT("FolderShortcuts");
+static LPCTSTR const kCopyHistoryValueName = TEXT("CopyHistory");
+
+static NSynchronization::CCriticalSection g_CS;
+
+#define Set32(p, v) SetUi32(((Byte *)p), v)
+#define SetBool(p, v) Set32(p, ((v) ? 1 : 0))
+
+#define Get32(p, dest) dest = GetUi32((const Byte *)p)
+#define GetBool(p, dest) dest = (GetUi32(p) != 0);
+
+/*
+struct CColumnHeader
+{
+  UInt32 Version;
+  UInt32 SortID;
+  UInt32 Ascending; // bool
+};
+*/
+
+static const UInt32 kListViewHeaderSize = 3 * 4;
+static const UInt32 kColumnInfoSize = 3 * 4;
+static const UInt32 kListViewVersion = 1;
+
+void CListViewInfo::Save(const UString &id) const
+{
+  const UInt32 dataSize = kListViewHeaderSize + kColumnInfoSize * Columns.Size();
+  CByteArr buf(dataSize);
+
+  Set32(buf, kListViewVersion);
+  Set32(buf + 4, SortID);
+  SetBool(buf + 8, Ascending);
+  FOR_VECTOR (i, Columns)
+  {
+    const CColumnInfo &column = Columns[i];
+    Byte *p = buf + kListViewHeaderSize + i * kColumnInfoSize;
+    Set32(p, column.PropID);
+    SetBool(p + 4, column.IsVisible);
+    Set32(p + 8, column.Width);
+  }
+  {
+    NSynchronization::CCriticalSectionLock lock(g_CS);
+    CKey key;
+    key.Create(HKEY_CURRENT_USER, kCulumnsKeyName);
+    key.SetValue(GetSystemString(id), (const Byte *)buf, dataSize);
+  }
+}
+
+void CListViewInfo::Read(const UString &id)
+{
+  Clear();
+  CByteBuffer buf;
+  UInt32 size;
+  {
+    NSynchronization::CCriticalSectionLock lock(g_CS);
+    CKey key;
+    if (key.Open(HKEY_CURRENT_USER, kCulumnsKeyName, KEY_READ) != ERROR_SUCCESS)
+      return;
+    if (key.QueryValue(GetSystemString(id), buf, size) != ERROR_SUCCESS)
+      return;
+  }
+  if (size < kListViewHeaderSize)
+    return;
+  UInt32 version;
+  Get32(buf, version);
+  if (version != kListViewVersion)
+    return;
+  Get32(buf + 4, SortID);
+  GetBool(buf + 8, Ascending);
+
+  IsLoaded = true;
+
+  size -= kListViewHeaderSize;
+  if (size % kColumnInfoSize != 0)
+    return;
+  unsigned numItems = size / kColumnInfoSize;
+  Columns.ClearAndReserve(numItems);
+  for (unsigned i = 0; i < numItems; i++)
+  {
+    CColumnInfo column;
+    const Byte *p = buf + kListViewHeaderSize + i * kColumnInfoSize;
+    Get32(p, column.PropID);
+    GetBool(p + 4, column.IsVisible);
+    Get32(p + 8, column.Width);
+    Columns.AddInReserved(column);
+  }
+}
+
+
+/*
+struct CWindowPosition
+{
+  RECT Rect;
+  UInt32 Maximized; // bool
+};
+
+struct CPanelsInfo
+{
+  UInt32 NumPanels;
+  UInt32 CurrentPanel;
+  UInt32 SplitterPos;
+};
+*/
+
+static const UInt32 kWindowPositionHeaderSize = 5 * 4;
+static const UInt32 kPanelsInfoHeaderSize = 3 * 4;
+
+void CWindowInfo::Save() const
+{
+  NSynchronization::CCriticalSectionLock lock(g_CS);
+  CKey key;
+  key.Create(HKEY_CURRENT_USER, kCUBasePath);
+  {
+    Byte buf[kWindowPositionHeaderSize];
+    Set32(buf,      rect.left);
+    Set32(buf +  4, rect.top);
+    Set32(buf +  8, rect.right);
+    Set32(buf + 12, rect.bottom);
+    SetBool(buf + 16, maximized);
+    key.SetValue(kPositionValueName, buf, kWindowPositionHeaderSize);
+  }
+  {
+    Byte buf[kPanelsInfoHeaderSize];
+    Set32(buf,      numPanels);
+    Set32(buf +  4, currentPanel);
+    Set32(buf +  8, splitterPos);
+    key.SetValue(kPanelsInfoValueName, buf, kPanelsInfoHeaderSize);
+  }
+}
+
+static bool QueryBuf(CKey &key, LPCTSTR name, CByteBuffer &buf, UInt32 dataSize)
+{
+  UInt32 size;
+  return key.QueryValue(name, buf, size) == ERROR_SUCCESS && size == dataSize;
+}
+
+void CWindowInfo::Read(bool &windowPosDefined, bool &panelInfoDefined)
+{
+  windowPosDefined = false;
+  panelInfoDefined = false;
+  NSynchronization::CCriticalSectionLock lock(g_CS);
+  CKey key;
+  if (key.Open(HKEY_CURRENT_USER, kCUBasePath, KEY_READ) != ERROR_SUCCESS)
+    return;
+  CByteBuffer buf;
+  if (QueryBuf(key, kPositionValueName, buf, kWindowPositionHeaderSize))
+  {
+    Get32(buf,      rect.left);
+    Get32(buf +  4, rect.top);
+    Get32(buf +  8, rect.right);
+    Get32(buf + 12, rect.bottom);
+    GetBool(buf + 16, maximized);
+    windowPosDefined = true;
+  }
+  if (QueryBuf(key, kPanelsInfoValueName, buf, kPanelsInfoHeaderSize))
+  {
+    Get32(buf,      numPanels);
+    Get32(buf +  4, currentPanel);
+    Get32(buf +  8, splitterPos);
+    panelInfoDefined = true;
+  }
+  return;
+}
+
+
+static void SaveUi32Val(const TCHAR *name, UInt32 value)
+{
+  CKey key;
+  key.Create(HKEY_CURRENT_USER, kCUBasePath);
+  key.SetValue(name, value);
+}
+
+static bool ReadUi32Val(const TCHAR *name, UInt32 &value)
+{
+  CKey key;
+  if (key.Open(HKEY_CURRENT_USER, kCUBasePath, KEY_READ) != ERROR_SUCCESS)
+    return false;
+  return key.QueryValue(name, value) == ERROR_SUCCESS;
+}
+
+void SaveToolbarsMask(UInt32 toolbarMask)
+{
+  SaveUi32Val(kToolbars, toolbarMask);
+}
+
+static const UInt32 kDefaultToolbarMask = ((UInt32)1 << 31) | 8 | 4 | 1;
+
+UInt32 ReadToolbarsMask()
+{
+  UInt32 mask;
+  if (!ReadUi32Val(kToolbars, mask))
+    return kDefaultToolbarMask;
+  return mask;
+}
+
+
+void CListMode::Save() const
+{
+  UInt32 t = 0;
+  for (int i = 0; i < 2; i++)
+    t |= ((Panels[i]) & 0xFF) << (i * 8);
+  SaveUi32Val(kListMode, t);
+}
+
+void CListMode::Read()
+{
+  Init();
+  UInt32 t;
+  if (!ReadUi32Val(kListMode, t))
+    return;
+  for (int i = 0; i < 2; i++)
+  {
+    Panels[i] = (t & 0xFF);
+    t >>= 8;
+  }
+}
+
+static UString GetPanelPathName(UInt32 panelIndex)
+{
+  UString s (kPanelPathValueName);
+  s.Add_UInt32(panelIndex);
+  return s;
+}
+
+void SavePanelPath(UInt32 panel, const UString &path)
+{
+  NSynchronization::CCriticalSectionLock lock(g_CS);
+  CKey key;
+  key.Create(HKEY_CURRENT_USER, kCUBasePath);
+  key.SetValue(GetPanelPathName(panel), path);
+}
+
+bool ReadPanelPath(UInt32 panel, UString &path)
+{
+  NSynchronization::CCriticalSectionLock lock(g_CS);
+  CKey key;
+  if (key.Open(HKEY_CURRENT_USER, kCUBasePath, KEY_READ) != ERROR_SUCCESS)
+    return false;
+  return (key.QueryValue(GetPanelPathName(panel), path) == ERROR_SUCCESS);
+}
+
+
+static void SaveStringList(LPCTSTR valueName, const UStringVector &folders)
+{
+  NSynchronization::CCriticalSectionLock lock(g_CS);
+  CKey key;
+  key.Create(HKEY_CURRENT_USER, kCUBasePath);
+  key.SetValue_Strings(valueName, folders);
+}
+
+static void ReadStringList(LPCTSTR valueName, UStringVector &folders)
+{
+  folders.Clear();
+  NSynchronization::CCriticalSectionLock lock(g_CS);
+  CKey key;
+  if (key.Open(HKEY_CURRENT_USER, kCUBasePath, KEY_READ) == ERROR_SUCCESS)
+    key.GetValue_Strings(valueName, folders);
+}
+
+void SaveFolderHistory(const UStringVector &folders)
+  { SaveStringList(kFolderHistoryValueName, folders); }
+void ReadFolderHistory(UStringVector &folders)
+  { ReadStringList(kFolderHistoryValueName, folders); }
+
+void SaveFastFolders(const UStringVector &folders)
+  { SaveStringList(kFastFoldersValueName, folders); }
+void ReadFastFolders(UStringVector &folders)
+  { ReadStringList(kFastFoldersValueName, folders); }
+
+void SaveCopyHistory(const UStringVector &folders)
+  { SaveStringList(kCopyHistoryValueName, folders); }
+void ReadCopyHistory(UStringVector &folders)
+  { ReadStringList(kCopyHistoryValueName, folders); }
+
+void AddUniqueStringToHeadOfList(UStringVector &list, const UString &s)
+{
+  for (unsigned i = 0; i < list.Size();)
+    if (s.IsEqualTo_NoCase(list[i]))
+      list.Delete(i);
+    else
+      i++;
+  list.Insert(0, s);
+}
diff --git a/CPP/7zip/UI/FileManager/ViewSettings.h b/CPP/7zip/UI/FileManager/ViewSettings.h
new file mode 100644
index 0000000..aeb6897
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ViewSettings.h
@@ -0,0 +1,115 @@
+// ViewSettings.h
+
+#ifndef __VIEW_SETTINGS_H
+#define __VIEW_SETTINGS_H
+
+#include "../../../Common/MyTypes.h"
+#include "../../../Common/MyString.h"
+
+struct CColumnInfo
+{
+  PROPID PropID;
+  bool IsVisible;
+  UInt32 Width;
+
+  bool IsEqual(const CColumnInfo &a) const
+  {
+    return PropID == a.PropID && IsVisible == a.IsVisible && Width == a.Width;
+  }
+};
+
+struct CListViewInfo
+{
+  CRecordVector<CColumnInfo> Columns;
+  PROPID SortID;
+  bool Ascending;
+  bool IsLoaded;
+
+  void Clear()
+  {
+    SortID = 0;
+    Ascending = true;
+    IsLoaded = false;
+    Columns.Clear();
+  }
+
+  CListViewInfo():
+    SortID(0),
+    Ascending(true),
+    IsLoaded(false)
+    {}
+
+  /*
+  int FindColumnWithID(PROPID propID) const
+  {
+    FOR_VECTOR (i, Columns)
+      if (Columns[i].PropID == propID)
+        return i;
+    return -1;
+  }
+  */
+
+  bool IsEqual(const CListViewInfo &info) const
+  {
+    if (Columns.Size() != info.Columns.Size() ||
+        SortID != info.SortID ||
+        Ascending != info.Ascending)
+      return false;
+    FOR_VECTOR (i, Columns)
+      if (!Columns[i].IsEqual(info.Columns[i]))
+        return false;
+    return true;
+  }
+
+  void Save(const UString &id) const;
+  void Read(const UString &id);
+};
+
+
+struct CWindowInfo
+{
+  RECT rect;
+  bool maximized;
+
+  UInt32 numPanels;
+  UInt32 currentPanel;
+  UInt32 splitterPos;
+
+  void Save() const;
+  void Read(bool &windowPosDefined, bool &panelInfoDefined);
+};
+
+void SaveToolbarsMask(UInt32 toolbarMask);
+UInt32 ReadToolbarsMask();
+
+const UInt32 kListMode_Report = 3;
+
+struct CListMode
+{
+  UInt32 Panels[2];
+  
+  void Init() { Panels[0] = Panels[1] = kListMode_Report; }
+  CListMode() { Init(); }
+  
+  void Save() const ;
+  void Read();
+};
+
+
+
+void SavePanelPath(UInt32 panel, const UString &path);
+bool ReadPanelPath(UInt32 panel, UString &path);
+
+
+void SaveFolderHistory(const UStringVector &folders);
+void ReadFolderHistory(UStringVector &folders);
+
+void SaveFastFolders(const UStringVector &folders);
+void ReadFastFolders(UStringVector &folders);
+
+void SaveCopyHistory(const UStringVector &folders);
+void ReadCopyHistory(UStringVector &folders);
+
+void AddUniqueStringToHeadOfList(UStringVector &list, const UString &s);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/makefile b/CPP/7zip/UI/FileManager/makefile
new file mode 100644
index 0000000..dd2a2f2
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/makefile
@@ -0,0 +1,107 @@
+PROG = 7zFM.exe
+CFLAGS = $(CFLAGS) \
+  -DEXTERNAL_CODECS \
+
+!include "FM.mak"
+
+COMMON_OBJS = \
+  $O\DynLimBuf.obj \
+  $O\IntToString.obj \
+  $O\Lang.obj \
+  $O\MyString.obj \
+  $O\MyVector.obj \
+  $O\NewHandler.obj \
+  $O\Random.obj \
+  $O\StringConvert.obj \
+  $O\StringToInt.obj \
+  $O\UTFConvert.obj \
+  $O\Wildcard.obj \
+
+WIN_OBJS = $(WIN_OBJS) \
+  $O\Clipboard.obj \
+  $O\CommonDialog.obj \
+  $O\DLL.obj \
+  $O\ErrorMsg.obj \
+  $O\FileDir.obj \
+  $O\FileFind.obj \
+  $O\FileIO.obj \
+  $O\FileLink.obj \
+  $O\FileName.obj \
+  $O\MemoryGlobal.obj \
+  $O\MemoryLock.obj \
+  $O\Menu.obj \
+  $O\ProcessUtils.obj \
+  $O\PropVariant.obj \
+  $O\PropVariantConv.obj \
+  $O\Registry.obj \
+  $O\ResourceString.obj \
+  $O\Shell.obj \
+  $O\Synchronization.obj \
+  $O\System.obj \
+  $O\TimeUtils.obj \
+  $O\Window.obj \
+
+
+WIN_CTRL_OBJS = \
+  $O\ComboBox.obj \
+  $O\Dialog.obj \
+  $O\ListView.obj \
+  $O\PropertyPage.obj \
+  $O\Window2.obj \
+
+7ZIP_COMMON_OBJS = \
+  $O\CreateCoder.obj \
+  $O\FilePathAutoRename.obj \
+  $O\FileStreams.obj \
+  $O\FilterCoder.obj \
+  $O\LimitedStreams.obj \
+  $O\MethodProps.obj \
+  $O\ProgressUtils.obj \
+  $O\PropId.obj \
+  $O\StreamObjects.obj \
+  $O\StreamUtils.obj \
+  $O\UniqBlocks.obj \
+
+UI_COMMON_OBJS = \
+  $O\ArchiveExtractCallback.obj \
+  $O\ArchiveName.obj \
+  $O\ArchiveOpenCallback.obj \
+  $O\CompressCall.obj \
+  $O\DefaultName.obj \
+  $O\EnumDirItems.obj \
+  $O\ExtractingFilePath.obj \
+  $O\HashCalc.obj \
+  $O\LoadCodecs.obj \
+  $O\OpenArchive.obj \
+  $O\PropIDUtils.obj \
+  $O\SetProperties.obj \
+  $O\SortUtils.obj \
+  $O\UpdateAction.obj \
+  $O\UpdateCallback.obj \
+  $O\UpdatePair.obj \
+  $O\UpdateProduce.obj \
+  $O\WorkDir.obj \
+  $O\ZipRegistry.obj \
+
+EXPLORER_OBJS = \
+  $O\ContextMenu.obj \
+  $O\RegistryContextMenu.obj \
+
+GUI_OBJS = \
+  $O\HashGUI.obj \
+  $O\UpdateCallbackGUI2.obj \
+
+COMPRESS_OBJS = \
+  $O\CopyCoder.obj \
+
+AR_COMMON_OBJS = \
+  $O\ItemNameUtils.obj \
+
+
+C_OBJS = $(C_OBJS) \
+  $O\Alloc.obj \
+  $O\CpuArch.obj \
+  $O\Sort.obj \
+  $O\Threads.obj \
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/UI/FileManager/resource.h b/CPP/7zip/UI/FileManager/resource.h
new file mode 100644
index 0000000..98cb4fd
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/resource.h
@@ -0,0 +1,182 @@
+#include "resourceGui.h"
+
+#define IDR_MENUBAR1      70
+#define IDM_MENU          71
+#define IDR_ACCELERATOR1  72
+
+#define IDB_ADD      100
+#define IDB_EXTRACT  101
+#define IDB_TEST     102
+#define IDB_COPY     103
+#define IDB_MOVE     104
+#define IDB_DELETE   105
+#define IDB_INFO     106
+
+#define IDB_ADD2     150
+#define IDB_EXTRACT2 151
+#define IDB_TEST2    152
+#define IDB_COPY2    153
+#define IDB_MOVE2    154
+#define IDB_DELETE2  155
+#define IDB_INFO2    156
+
+#define IDM_HASH_ALL             101
+#define IDM_CRC32                102
+#define IDM_CRC64                103
+#define IDM_SHA1                 104
+#define IDM_SHA256               105
+
+#define IDM_OPEN                 540
+#define IDM_OPEN_INSIDE          541
+#define IDM_OPEN_OUTSIDE         542
+#define IDM_FILE_VIEW            543
+#define IDM_FILE_EDIT            544
+#define IDM_RENAME               545
+#define IDM_COPY_TO              546
+#define IDM_MOVE_TO              547
+#define IDM_DELETE               548
+#define IDM_SPLIT                549
+#define IDM_COMBINE              550
+#define IDM_PROPERTIES           551
+#define IDM_COMMENT              552
+#define IDM_CRC                  553
+#define IDM_DIFF                 554
+#define IDM_CREATE_FOLDER        555
+#define IDM_CREATE_FILE          556
+// #define IDM_EXIT                 557
+#define IDM_LINK                 558
+#define IDM_ALT_STREAMS          559
+
+#define IDM_VER_EDIT             580
+#define IDM_VER_COMMIT           581
+#define IDM_VER_REVERT           582
+#define IDM_VER_DIFF             583
+
+#define IDM_OPEN_INSIDE_ONE      590
+#define IDM_OPEN_INSIDE_PARSER   591
+
+#define IDM_SELECT_ALL           600
+#define IDM_DESELECT_ALL         601
+#define IDM_INVERT_SELECTION     602
+#define IDM_SELECT               603
+#define IDM_DESELECT             604
+#define IDM_SELECT_BY_TYPE       605
+#define IDM_DESELECT_BY_TYPE     606
+
+#define IDM_VIEW_LARGE_ICONS     700
+#define IDM_VIEW_SMALL_ICONS     701
+#define IDM_VIEW_LIST            702
+#define IDM_VIEW_DETAILS         703
+
+#define IDM_VIEW_ARANGE_BY_NAME  710
+#define IDM_VIEW_ARANGE_BY_TYPE  711
+#define IDM_VIEW_ARANGE_BY_DATE  712
+#define IDM_VIEW_ARANGE_BY_SIZE  713
+
+#define IDM_VIEW_ARANGE_NO_SORT  730
+#define IDM_VIEW_FLAT_VIEW       731
+#define IDM_VIEW_TWO_PANELS      732
+#define IDM_VIEW_TOOLBARS        733
+#define IDM_OPEN_ROOT_FOLDER     734
+#define IDM_OPEN_PARENT_FOLDER   735
+#define IDM_FOLDERS_HISTORY      736
+#define IDM_VIEW_REFRESH         737
+#define IDM_VIEW_AUTO_REFRESH    738
+// #define IDM_VIEW_SHOW_DELETED    739
+// #define IDM_VIEW_SHOW_STREAMS    740
+
+#define IDM_VIEW_ARCHIVE_TOOLBAR            750
+#define IDM_VIEW_STANDARD_TOOLBAR           751
+#define IDM_VIEW_TOOLBARS_LARGE_BUTTONS     752
+#define IDM_VIEW_TOOLBARS_SHOW_BUTTONS_TEXT 753
+
+#define IDM_VIEW_TIME            761
+
+#define IDS_BOOKMARK             801
+
+#define IDM_OPTIONS              900
+#define IDM_BENCHMARK            901
+#define IDM_BENCHMARK2           902
+
+#define IDM_HELP_CONTENTS        960
+#define IDM_ABOUT                961
+
+#define IDS_OPTIONS                     2100
+
+#define IDS_N_SELECTED_ITEMS            3002
+
+#define IDS_FILE_EXIST                  3008
+#define IDS_WANT_UPDATE_MODIFIED_FILE   3009
+#define IDS_CANNOT_UPDATE_FILE          3010
+#define IDS_CANNOT_START_EDITOR         3011
+#define IDS_VIRUS                       3012
+#define IDS_MESSAGE_UNSUPPORTED_OPERATION_FOR_LONG_PATH_FOLDER  3013
+#define IDS_SELECT_ONE_FILE             3014
+#define IDS_SELECT_FILES                3015
+#define IDS_TOO_MANY_ITEMS              3016
+
+#define IDS_COPY                        6000
+#define IDS_MOVE                        6001
+#define IDS_COPY_TO                     6002
+#define IDS_MOVE_TO                     6003
+#define IDS_COPYING                     6004
+#define IDS_MOVING                      6005
+#define IDS_RENAMING                    6006
+
+#define IDS_OPERATION_IS_NOT_SUPPORTED  6008
+#define IDS_ERROR_RENAMING              6009
+#define IDS_CONFIRM_FILE_COPY           6010
+#define IDS_WANT_TO_COPY_FILES          6011
+
+#define IDS_CONFIRM_FILE_DELETE         6100
+#define IDS_CONFIRM_FOLDER_DELETE       6101
+#define IDS_CONFIRM_ITEMS_DELETE        6102
+#define IDS_WANT_TO_DELETE_FILE         6103
+#define IDS_WANT_TO_DELETE_FOLDER       6104
+#define IDS_WANT_TO_DELETE_ITEMS        6105
+#define IDS_DELETING                    6106
+#define IDS_ERROR_DELETING              6107
+#define IDS_ERROR_LONG_PATH_TO_RECYCLE  6108
+
+#define IDS_CREATE_FOLDER               6300
+#define IDS_CREATE_FILE                 6301
+#define IDS_CREATE_FOLDER_NAME          6302
+#define IDS_CREATE_FILE_NAME            6303
+#define IDS_CREATE_FOLDER_DEFAULT_NAME  6304
+#define IDS_CREATE_FILE_DEFAULT_NAME    6305
+#define IDS_CREATE_FOLDER_ERROR         6306
+#define IDS_CREATE_FILE_ERROR           6307
+
+#define IDS_COMMENT                     6400
+#define IDS_COMMENT2                    6401
+#define IDS_SELECT                      6402
+#define IDS_DESELECT                    6403
+#define IDS_SELECT_MASK                 6404
+
+#define IDS_PROPERTIES                  6600
+#define IDS_FOLDERS_HISTORY             6601
+
+#define IDS_COMPUTER                    7100
+#define IDS_NETWORK                     7101
+#define IDS_DOCUMENTS                   7102
+#define IDS_SYSTEM                      7103
+
+#define IDS_ADD                         7200
+#define IDS_EXTRACT                     7201
+#define IDS_TEST                        7202
+#define IDS_BUTTON_COPY                 7203
+#define IDS_BUTTON_MOVE                 7204
+#define IDS_BUTTON_DELETE               7205
+#define IDS_BUTTON_INFO                 7206
+
+#define IDS_SPLITTING                   7303
+#define IDS_SPLIT_CONFIRM_TITLE         7304
+#define IDS_SPLIT_CONFIRM_MESSAGE       7305
+#define IDS_SPLIT_VOL_MUST_BE_SMALLER   7306
+
+#define IDS_COMBINE                     7400
+#define IDS_COMBINE_TO                  7401
+#define IDS_COMBINING                   7402
+#define IDS_COMBINE_SELECT_ONE_FILE     7403
+#define IDS_COMBINE_CANT_DETECT_SPLIT_FILE 7404
+#define IDS_COMBINE_CANT_FIND_MORE_THAN_ONE_PART 7405
diff --git a/CPP/7zip/UI/FileManager/resource.rc b/CPP/7zip/UI/FileManager/resource.rc
new file mode 100644
index 0000000..fc2c840
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/resource.rc
@@ -0,0 +1,268 @@
+#include "../../MyVersionInfo.rc"
+#include "../../GuiCommon.rc"
+#include "resource.h"
+
+MY_VERSION_INFO_APP("7-Zip File Manager", "7zFM")
+
+IDR_ACCELERATOR1 ACCELERATORS
+BEGIN
+//  "N",     IDM_CREATE_FILE,      VIRTKEY, CONTROL, NOINVERT
+  VK_F1,   IDM_HELP_CONTENTS,    VIRTKEY, NOINVERT
+  VK_F12,  IDM_FOLDERS_HISTORY,  VIRTKEY, ALT, NOINVERT
+//  VK_F7,   IDM_CREATE_FOLDER,    VIRTKEY, NOINVERT
+END
+
+
+IDM_MENU MENU
+BEGIN
+  POPUP "&File"
+  BEGIN
+    MENUITEM "&Open\tEnter",                IDM_OPEN
+    MENUITEM "Open &Inside\tCtrl+PgDn",     IDM_OPEN_INSIDE
+    MENUITEM "Open Inside *",               IDM_OPEN_INSIDE_ONE
+    MENUITEM "Open Inside #",               IDM_OPEN_INSIDE_PARSER
+    MENUITEM "Open O&utside\tShift+Enter",  IDM_OPEN_OUTSIDE
+    MENUITEM "&View\tF3",                   IDM_FILE_VIEW
+    MENUITEM "&Edit\tF4",                   IDM_FILE_EDIT
+    MENUITEM SEPARATOR
+    MENUITEM "Rena&me\tF2",                 IDM_RENAME
+    MENUITEM "&Copy To...\tF5",             IDM_COPY_TO
+    MENUITEM "&Move To...\tF6",             IDM_MOVE_TO
+    MENUITEM "&Delete\tDel",                IDM_DELETE
+    MENUITEM SEPARATOR
+    MENUITEM "&Split file...",              IDM_SPLIT
+    MENUITEM "Com&bine files...",           IDM_COMBINE
+    MENUITEM SEPARATOR
+    MENUITEM "P&roperties\tAlt+Enter",      IDM_PROPERTIES
+    MENUITEM "Comme&nt...\tCtrl+Z",         IDM_COMMENT
+    // MENUITEM "Calculate checksum",          IDM_CRC
+    POPUP "CRC"
+    BEGIN
+      MENUITEM "CRC-32",                    IDM_CRC32
+      MENUITEM "CRC-64",                    IDM_CRC64
+      MENUITEM "SHA-1",                     IDM_SHA1
+      MENUITEM "SHA-256",                   IDM_SHA256
+      MENUITEM "*",                         IDM_HASH_ALL
+    END
+    MENUITEM "Di&ff",                       IDM_DIFF
+    MENUITEM SEPARATOR
+    MENUITEM "Create Folder\tF7",           IDM_CREATE_FOLDER
+    MENUITEM "Create File\tCtrl+N",         IDM_CREATE_FILE
+    MENUITEM SEPARATOR
+    MENUITEM "&Link...",                    IDM_LINK
+    MENUITEM "&Alternate streams",          IDM_ALT_STREAMS
+    MENUITEM SEPARATOR
+    MENUITEM "E&xit\tAlt+F4",               IDCLOSE
+  END
+  POPUP "&Edit"
+  BEGIN
+    // MENUITEM "Cu&t\tCtrl+X",                IDM_EDIT_CUT, GRAYED
+    // MENUITEM "&Copy\tCtrl+C",               IDM_EDIT_COPY, GRAYED
+    // MENUITEM "&Paste\tCtrl+V",              IDM_EDIT_PASTE, GRAYED
+    // MENUITEM SEPARATOR
+    MENUITEM "Select &All\tShift+[Grey +]", IDM_SELECT_ALL
+    MENUITEM "Deselect All\tShift+[Grey -]", IDM_DESELECT_ALL
+    MENUITEM "&Invert Selection\tGrey *",   IDM_INVERT_SELECTION
+    MENUITEM "Select...\tGrey +",           IDM_SELECT
+    MENUITEM "Deselect...\tGrey -",         IDM_DESELECT
+    MENUITEM "Select by Type\tAlt+[Grey+]", IDM_SELECT_BY_TYPE
+    MENUITEM "Deselect by Type\tAlt+[Grey -]", IDM_DESELECT_BY_TYPE
+  END
+  POPUP "&View"
+  BEGIN
+    MENUITEM "Lar&ge Icons\tCtrl+1",        IDM_VIEW_LARGE_ICONS
+    MENUITEM "S&mall Icons\tCtrl+2",        IDM_VIEW_SMALL_ICONS
+    MENUITEM "&List\tCtrl+3",               IDM_VIEW_LIST
+    MENUITEM "&Details\tCtrl+4",            IDM_VIEW_DETAILS, CHECKED
+    MENUITEM SEPARATOR
+    MENUITEM "Name\tCtrl+F3",               IDM_VIEW_ARANGE_BY_NAME
+    MENUITEM "Type\tCtrl+F4",               IDM_VIEW_ARANGE_BY_TYPE
+    MENUITEM "Date\tCtrl+F5",               IDM_VIEW_ARANGE_BY_DATE
+    MENUITEM "Size\tCtrl+F6",               IDM_VIEW_ARANGE_BY_SIZE
+    MENUITEM "Unsorted\tCtrl+F7",           IDM_VIEW_ARANGE_NO_SORT
+    MENUITEM SEPARATOR
+    MENUITEM "Flat View",                   IDM_VIEW_FLAT_VIEW
+    MENUITEM "&2 Panels\tF9",               IDM_VIEW_TWO_PANELS
+
+    POPUP "2017"
+    BEGIN
+      MENUITEM "Time",                      IDM_VIEW_TIME
+    END
+
+    POPUP "Toolbars"
+    BEGIN
+      MENUITEM "Archive Toolbar",           IDM_VIEW_ARCHIVE_TOOLBAR
+      MENUITEM "Standard Toolbar",          IDM_VIEW_STANDARD_TOOLBAR
+      MENUITEM SEPARATOR
+      MENUITEM "Large Buttons",             IDM_VIEW_TOOLBARS_LARGE_BUTTONS
+      MENUITEM "Show Buttons Text",         IDM_VIEW_TOOLBARS_SHOW_BUTTONS_TEXT
+    END
+    MENUITEM "Open Root Folder\t\\",        IDM_OPEN_ROOT_FOLDER
+    MENUITEM "Up One Level\tBackspace",     IDM_OPEN_PARENT_FOLDER
+    MENUITEM "Folders History...\tAlt+F12", IDM_FOLDERS_HISTORY
+    MENUITEM "&Refresh\tCtrl+R",            IDM_VIEW_REFRESH
+    MENUITEM "Auto Refresh",                IDM_VIEW_AUTO_REFRESH
+
+    // MENUITEM "Show NTFS streams",           IDM_VIEW_SHOW_STREAMS
+    // MENUITEM "Show deleted files",          IDM_VIEW_SHOW_DELETED
+
+  END
+  POPUP "F&avorites"
+  BEGIN
+    POPUP "&Add folder to Favorites as"
+    BEGIN
+        MENUITEM SEPARATOR
+    END
+    MENUITEM SEPARATOR
+  END
+  POPUP "&Tools"
+  BEGIN
+    MENUITEM "&Options...",                 IDM_OPTIONS
+    MENUITEM SEPARATOR
+    MENUITEM "&Benchmark",                  IDM_BENCHMARK
+  #ifdef UNDER_CE
+    MENUITEM "Benchmark 2",                 IDM_BENCHMARK2
+  #endif
+  #ifndef UNDER_CE
+  END
+  POPUP "&Help"
+  BEGIN
+    MENUITEM "&Contents...\tF1",            IDM_HELP_CONTENTS
+  #endif
+    MENUITEM SEPARATOR
+  MENUITEM "&About 7-Zip...",               IDM_ABOUT
+  END
+END
+
+
+IDI_ICON  ICON  "../../UI/FileManager/FM.ico"
+
+#ifndef UNDER_CE
+1  24  MOVEABLE PURE   "../../UI/FileManager/7zFM.exe.manifest"
+#endif
+
+IDB_ADD        BITMAP  "../../UI/FileManager/Add.bmp"
+IDB_EXTRACT    BITMAP  "../../UI/FileManager/Extract.bmp"
+IDB_TEST       BITMAP  "../../UI/FileManager/Test.bmp"
+IDB_COPY       BITMAP  "../../UI/FileManager/Copy.bmp"
+IDB_MOVE       BITMAP  "../../UI/FileManager/Move.bmp"
+IDB_DELETE     BITMAP  "../../UI/FileManager/Delete.bmp"
+IDB_INFO       BITMAP  "../../UI/FileManager/Info.bmp"
+IDB_ADD2       BITMAP  "../../UI/FileManager/Add2.bmp"
+IDB_EXTRACT2   BITMAP  "../../UI/FileManager/Extract2.bmp"
+IDB_TEST2      BITMAP  "../../UI/FileManager/Test2.bmp"
+IDB_COPY2      BITMAP  "../../UI/FileManager/Copy2.bmp"
+IDB_MOVE2      BITMAP  "../../UI/FileManager/Move2.bmp"
+IDB_DELETE2    BITMAP  "../../UI/FileManager/Delete2.bmp"
+IDB_INFO2      BITMAP  "../../UI/FileManager/Info2.bmp"
+
+
+STRINGTABLE
+BEGIN
+  IDS_BOOKMARK   "Bookmark"
+
+  IDS_OPTIONS    "Options"
+
+  IDS_N_SELECTED_ITEMS  "{0} object(s) selected"
+
+  IDS_FILE_EXIST  "File {0} is already exist"
+  IDS_WANT_UPDATE_MODIFIED_FILE  "File '{0}' was modified.\nDo you want to update it in the archive?"
+  IDS_CANNOT_UPDATE_FILE   "Cannot update file\n'{0}'"
+  IDS_CANNOT_START_EDITOR  "Cannot start editor."
+  IDS_VIRUS                "The file looks like a virus (the file name contains long spaces in name)."
+  IDS_MESSAGE_UNSUPPORTED_OPERATION_FOR_LONG_PATH_FOLDER "The operation cannot be called from a folder that has a long path."
+  IDS_SELECT_ONE_FILE      "You must select one file"
+  IDS_SELECT_FILES         "You must select one or more files"
+  IDS_TOO_MANY_ITEMS       "Too many items"
+
+  IDS_COPY      "Copy"
+  IDS_MOVE      "Move"
+  IDS_COPY_TO   "Copy to:"
+  IDS_MOVE_TO   "Move to:"
+  IDS_COPYING   "Copying..."
+  IDS_MOVING    "Moving..."
+  IDS_RENAMING  "Renaming..."
+
+  IDS_OPERATION_IS_NOT_SUPPORTED  "Operation is not supported."
+  IDS_ERROR_RENAMING  "Error Renaming File or Folder"
+  IDS_CONFIRM_FILE_COPY   "Confirm File Copy"
+  IDS_WANT_TO_COPY_FILES  "Are you sure you want to copy files to archive"
+
+  IDS_CONFIRM_FILE_DELETE   "Confirm File Delete"
+  IDS_CONFIRM_FOLDER_DELETE "Confirm Folder Delete"
+  IDS_CONFIRM_ITEMS_DELETE  "Confirm Multiple File Delete"
+  IDS_WANT_TO_DELETE_FILE   "Are you sure you want to delete '{0}'?"
+  IDS_WANT_TO_DELETE_FOLDER "Are you sure you want to delete the folder '{0}' and all its contents?"
+  IDS_WANT_TO_DELETE_ITEMS  "Are you sure you want to delete these {0} items?"
+  IDS_DELETING              "Deleting..."
+  IDS_ERROR_DELETING        "Error Deleting File or Folder"
+  IDS_ERROR_LONG_PATH_TO_RECYCLE  "The system cannot move a file with long path to the Recycle Bin"
+  
+  IDS_CREATE_FOLDER       "Create Folder"
+  IDS_CREATE_FILE         "Create File"
+  IDS_CREATE_FOLDER_NAME  "Folder name:"
+  IDS_CREATE_FILE_NAME    "File Name:"
+  IDS_CREATE_FOLDER_DEFAULT_NAME  "New Folder"
+  IDS_CREATE_FILE_DEFAULT_NAME    "New File"
+  IDS_CREATE_FOLDER_ERROR "Error Creating Folder"
+  IDS_CREATE_FILE_ERROR   "Error Creating File"
+
+  IDS_COMMENT      "Comment"
+  IDS_COMMENT2     "&Comment:"
+  IDS_SELECT       "Select"
+  IDS_DESELECT     "Deselect"
+  IDS_SELECT_MASK  "Mask:"
+
+  IDS_PROPERTIES   "Properties"
+  IDS_FOLDERS_HISTORY  "Folders History"
+
+  IDS_COMPUTER   "Computer"
+  IDS_NETWORK    "Network"
+  IDS_DOCUMENTS  "Documents"
+  IDS_SYSTEM     "System"
+
+  IDS_ADD            "Add"
+  IDS_EXTRACT        "Extract"
+  IDS_TEST           "Test"
+  IDS_BUTTON_COPY    "Copy"
+  IDS_BUTTON_MOVE    "Move"
+  IDS_BUTTON_DELETE  "Delete"
+  IDS_BUTTON_INFO    "Info"
+
+  IDS_SPLITTING            "Splitting..."
+  IDS_SPLIT_CONFIRM_TITLE  "Confirm Splitting"
+  IDS_SPLIT_CONFIRM_MESSAGE  "Are you sure you want to split file into {0} volumes?"
+  IDS_SPLIT_VOL_MUST_BE_SMALLER "Volume size must be smaller than size of original file"
+
+  IDS_COMBINE     "Combine Files"
+  IDS_COMBINE_TO  "&Combine to:"
+  IDS_COMBINING   "Combining..."
+  IDS_COMBINE_SELECT_ONE_FILE  "Select only first part of split file"
+  IDS_COMBINE_CANT_DETECT_SPLIT_FILE  "Cannot detect file as split file"
+  IDS_COMBINE_CANT_FIND_MORE_THAN_ONE_PART  "Cannot find more than one part of split file"
+
+END
+
+#include "AboutDialog.rc"
+#include "BrowseDialog.rc"
+#include "ComboDialog.rc"
+#include "CopyDialog.rc"
+#include "EditDialog.rc"
+#include "EditPage.rc"
+#include "FoldersPage.rc"
+#include "LangPage.rc"
+#include "LinkDialog.rc"
+#include "ListViewDialog.rc"
+#include "MenuPage.rc"
+#include "MessagesDialog.rc"
+#include "OverwriteDialog.rc"
+#include "PasswordDialog.rc"
+#include "ProgressDialog2.rc"
+#include "PropertyName.rc"
+#include "SettingsPage.rc"
+#include "SplitDialog.rc"
+#include "SystemPage.rc"
+#include "../GUI/Extract.rc"
+#include "../GUI/resource3.rc"
+#include "../Explorer/resource2.rc"
+#include "resourceGui.rc"
diff --git a/CPP/7zip/UI/FileManager/resourceGui.h b/CPP/7zip/UI/FileManager/resourceGui.h
new file mode 100644
index 0000000..7c1b40e
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/resourceGui.h
@@ -0,0 +1,15 @@
+#define IDI_ICON  1
+
+#define IDS_MESSAGE_NO_ERRORS           3001
+
+#define IDS_PROGRESS_TESTING            3302
+#define IDS_OPENNING                    3303
+#define IDS_SCANNING                    3304
+
+#define IDS_CHECKSUM_CALCULATING        7500
+#define IDS_CHECKSUM_INFORMATION        7501
+#define IDS_CHECKSUM_CRC_DATA           7502
+#define IDS_CHECKSUM_CRC_DATA_NAMES     7503
+#define IDS_CHECKSUM_CRC_STREAMS_NAMES  7504
+
+#define IDS_INCORRECT_VOLUME_SIZE       7307
diff --git a/CPP/7zip/UI/FileManager/resourceGui.rc b/CPP/7zip/UI/FileManager/resourceGui.rc
new file mode 100644
index 0000000..f748e0b
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/resourceGui.rc
@@ -0,0 +1,19 @@
+#include "resourceGui.h"
+
+STRINGTABLE
+BEGIN
+  IDS_MESSAGE_NO_ERRORS     "There are no errors"
+
+  IDS_PROGRESS_TESTING      "Testing"
+
+  IDS_CHECKSUM_CALCULATING    "Checksum calculating..."
+  IDS_CHECKSUM_INFORMATION    "Checksum information"
+  IDS_CHECKSUM_CRC_DATA       "CRC checksum for data:"
+  IDS_CHECKSUM_CRC_DATA_NAMES "CRC checksum for data and names:"
+  IDS_CHECKSUM_CRC_STREAMS_NAMES "CRC checksum for streams and names:"
+
+  IDS_INCORRECT_VOLUME_SIZE "Incorrect volume size"
+
+  IDS_OPENNING  "Opening..."
+  IDS_SCANNING  "Scanning..."
+END