7zip-native 0.0.0-stage → 0.0.1

package/vendor/7zip/CPP/7zip/UI/FileManager/PanelFolderChange.cpp

@@ -0,0 +1,1122 @@
+// 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;
+    /* we will Empty() sysPath variable, if we need to BindToFolder()
+       directly with (path) variable */
+    const 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)))
+    {
+      // if base item for alt streams prefix "base:" exists, we will use it
+      UString baseFile = sysPath;
+      baseFile.DeleteBack();
+      if (NFind::DoesFileOrDirExist(us2fs(baseFile)))
+        sysPath.Empty();
+    }
+    #endif
+    
+    CFileInfo fileInfo;
+    
+    while (!sysPath.IsEmpty())
+    {
+      if (sysPath.Len() <= prefixSize)
+      {
+        path.DeleteFrom(prefixSize);
+        sysPath.Empty();
+        break;
+      }
+
+      fileInfo.ClearBase();
+      if (IsPathSepar(sysPath.Back()))
+      {
+        /* Windows 10 by default doesn't allow look "Local Settings" that is junction to "AppData\Local",
+           but it does allow look "Local Settings\Temp\*"
+           22.02: at first we try to use paths with slashes "path\" */
+        CFileInfo fi;
+        // CFindFile findFile;
+        // FString path2 = us2fs(sysPath);
+        // path2 += '*'; // CHAR_ANY_MASK;
+        // if (findFile.FindFirst(path2, fi))
+        CEnumerator enumerator;
+        enumerator.SetDirPrefix(us2fs(sysPath));
+        bool found = false;
+        if (enumerator.Next(fi, found))
+        {
+          // sysPath.DeleteBack();
+          fileInfo.SetAsDir();
+          fileInfo.Size = 0;
+          fileInfo.Name.Empty();
+          break;
+        }
+        sysPath.DeleteBack();
+        continue;
+      }
+
+      if (fileInfo.Find(us2fs(sysPath)))
+        break;
+      int pos = sysPath.ReverseFind_PathSepar();
+      if (pos < 0)
+      {
+        sysPath.Empty();
+        break;
+      }
+      {
+        if ((unsigned)pos != sysPath.Len() - 1)
+          pos++;
+        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);
+      const int slashPos = NName::FindSepar(s);
+      unsigned skipLen = s.Len();
+      if (slashPos >= 0)
+      {
+        s.DeleteFrom((unsigned)slashPos);
+        skipLen = (unsigned)slashPos + 1;
+      }
+
+      CMyComPtr<IFolderFolder> newFolder;
+      _folder->BindToFolder(s, &newFolder);
+      if (newFolder)
+        curPos += skipLen;
+      else if (_folderAltStreams)
+      {
+        const int pos = s.Find(L':');
+        if (pos >= 0)
+        {
+          UString baseName = s;
+          baseName.DeleteFrom((unsigned)pos);
+          if (_folderAltStreams->BindToAltStreams(baseName, &newFolder) == S_OK && newFolder)
+            curPos += (unsigned)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_for_DirPath(CFSTR path, DWORD attrib)
+{
+  attrib |= FILE_ATTRIBUTE_DIRECTORY; // optional
+  int index = -1;
+  if (Shell_GetFileInfo_SysIconIndex_for_Path_attrib_iconIndexRef(path, attrib, index))
+    if (index >= 0)
+      return index;
+  return g_Ext_to_Icon_Map.GetIconIndex_DIR(attrib);
+}
+
+
+extern UString RootFolder_GetName_Computer(int &iconIndex);
+extern UString RootFolder_GetName_Network(int &iconIndex);
+extern UString RootFolder_GetName_Documents(int &iconIndex);
+
+
+static int Find_FileExtension_DotPos_in_path(const wchar_t *path)
+{
+  int dotPos = -1;
+  unsigned i;
+  for (i = 0;; i++)
+  {
+    const wchar_t c = path[i];
+    if (c == 0)
+      return dotPos;
+    if (c == '.')
+      dotPos = (int)i;
+    else if (IS_PATH_SEPAR(c) || c == ':')
+      dotPos = -1;
+  }
+}
+
+
+void CPanel::LoadFullPathAndShow()
+{
+  LoadFullPath();
+  _appState->FolderHistory.AddString(_currentFolderPrefix);
+
+  _headerComboBox.SetText(_currentFolderPrefix);
+
+  #ifndef UNDER_CE
+
+  COMBOBOXEXITEM item;
+  item.mask = 0;
+  item.iImage = -1;
+
+  UString path = _currentFolderPrefix;
+  // path = "\\\\.\\PhysicalDrive1\\"; // for debug
+  // path = "\\\\.\\y:\\"; // for debug
+  if (!path.IsEmpty())
+  {
+    const unsigned rootPrefixSize = NName::GetRootPrefixSize(path);
+    if (rootPrefixSize == 0 && path[0] != '\\')
+    {
+      int iconIndex = -1;
+      UString name_Computer = RootFolder_GetName_Computer(iconIndex);
+      name_Computer.Add_PathSepar();
+      if (path == name_Computer
+          || path.IsEqualTo("\\\\?\\"))
+        item.iImage = iconIndex;
+      else
+      {
+        UString name = RootFolder_GetName_Network(iconIndex);
+        name.Add_PathSepar();
+        if (path == name)
+          item.iImage = iconIndex;
+      }
+    }
+
+    if (item.iImage < 0)
+    {
+      if (rootPrefixSize == 0 || rootPrefixSize == path.Len())
+      {
+        DWORD attrib = FILE_ATTRIBUTE_DIRECTORY;
+        CFileInfo info;
+        if (info.Find(us2fs(path)))
+          attrib = info.Attrib;
+        NName::If_IsSuperPath_RemoveSuperPrefix(path);
+        item.iImage = GetRealIconIndex_for_DirPath(us2fs(path), attrib);
+      }
+      else if (rootPrefixSize == NName::kDevicePathPrefixSize
+          && NName::IsDevicePath(us2fs(path.Left(path.Len() - 1))))
+      {
+        if (path.IsPrefixedBy_Ascii_NoCase("\\\\.\\"))
+          path.DeleteFrontal(4);
+        if (path.Len() > 3) // is not "c:\\"
+        {
+          // PhysicalDrive
+          if (path.Back() == '\\')
+            path.DeleteBack();
+        }
+        item.iImage = Shell_GetFileInfo_SysIconIndex_for_Path(us2fs(path), FILE_ATTRIBUTE_ARCHIVE);
+      }
+      else
+      {
+        if (path.Back() == '\\')
+          path.DeleteBack();
+        bool need_Fs_Check = true;
+        bool is_File = false;
+        if (!_parentFolders.IsEmpty())
+        {
+          const CFolderLink &link = _parentFolders.Back();
+          if (link.VirtualPath == path)
+          {
+            is_File = true;
+            if (_parentFolders.Size() != 1)
+              need_Fs_Check = false;
+          }
+          else
+            need_Fs_Check = false;
+        }
+        if (need_Fs_Check)
+        {
+          CFileInfo info;
+          const bool finded = info.Find(us2fs(path));
+          DWORD attrib = FILE_ATTRIBUTE_DIRECTORY;
+          if (finded)
+            attrib = info.Attrib;
+          item.iImage = Shell_GetFileInfo_SysIconIndex_for_Path(us2fs(path), attrib);
+        }
+        if (item.iImage <= 0 && is_File)
+        {
+          int dotPos = Find_FileExtension_DotPos_in_path(path);
+          if (dotPos < 0)
+            dotPos = (int)path.Len();
+          item.iImage = g_Ext_to_Icon_Map.GetIconIndex(FILE_ATTRIBUTE_ARCHIVE, path.Ptr(dotPos));
+        }
+      }
+    }
+  }
+
+  if (item.iImage < 0)
+    item.iImage = g_Ext_to_Icon_Map.GetIconIndex_DIR();
+  // if (item.iImage < 0) item.iImage = 0;
+  // item.iImage = -1; // for debug
+  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, unsigned indent, bool addToList)
+{
+  #ifdef UNDER_CE
+
+  UString s;
+  iconIndex = iconIndex;
+  for (unsigned i = 0; i < indent; i++)
+    s += "  ";
+  _headerComboBox.AddString(s + name);
+  
+  #else
+  
+  COMBOBOXEXITEMW item;
+  item.mask = CBEIF_TEXT | CBEIF_INDENT;
+  if (iconIndex < 0)
+    iconIndex = g_Ext_to_Icon_Map.GetIconIndex_DIR();
+  item.iSelectedImage = item.iImage = iconIndex;
+  if (iconIndex >= 0)
+    item.mask |= (CBEIF_IMAGE | CBEIF_SELECTEDIMAGE);
+  item.iItem = -1;
+  item.iIndent = (int)indent;
+  item.pszText = name.Ptr_non_const();
+  _headerComboBox.InsertItem(&item);
+  
+  #endif
+
+  if (addToList)
+  {
+    UString s = name;
+    s.Add_PathSepar();
+    ComboBoxPaths.Add(s);
+  }
+}
+
+
+bool CPanel::OnComboBoxCommand(UINT code, LPARAM /* param */, LRESULT &result)
+{
+  result = FALSE;
+  switch (code)
+  {
+    case CBN_DROPDOWN:
+    {
+      ComboBoxPaths.Clear();
+      _headerComboBox.ResetContent();
+      
+      UString sumPath;
+      UStringVector pathParts;
+      unsigned indent = 0;
+      {
+        UString path = _currentFolderPrefix;
+        // path = "\\\\.\\y:\\"; // for debug
+        UString prefix0;
+        if (path.IsPrefixedBy_Ascii_NoCase("\\\\"))
+        {
+          const int separ = FindCharPosInString(path.Ptr(2), '\\');
+          if (separ > 0
+            && (separ > 1 || path[2] != '.')) // "\\\\.\\" will be processed later
+          {
+            const UString s = path.Left(2 + separ);
+            prefix0 = s;
+            prefix0.Add_PathSepar();
+            AddComboBoxItem(s,
+                GetRealIconIndex_for_DirPath(us2fs(prefix0), FILE_ATTRIBUTE_DIRECTORY),
+                indent++,
+                false); // addToList
+            ComboBoxPaths.Add(prefix0);
+          }
+        }
+        
+        unsigned rootPrefixSize = NName::GetRootPrefixSize(path);
+
+        sumPath = path;
+        
+        if (rootPrefixSize <= prefix0.Len())
+        {
+          rootPrefixSize = prefix0.Len();
+          sumPath.DeleteFrom(rootPrefixSize);
+        }
+        else
+        {
+          // rootPrefixSize > prefix0.Len()
+          sumPath.DeleteFrom(rootPrefixSize);
+          
+          CFileInfo info;
+          DWORD attrib = FILE_ATTRIBUTE_DIRECTORY;
+          if (info.Find(us2fs(sumPath)) && info.IsDir())
+            attrib = info.Attrib;
+          UString s = sumPath.Ptr(prefix0.Len());
+          if (!s.IsEmpty())
+          {
+            const wchar_t c = s.Back();
+            if (IS_PATH_SEPAR(c))
+              s.DeleteBack();
+          }
+          UString path_for_icon = sumPath;
+          NName::If_IsSuperPath_RemoveSuperPrefix(path_for_icon);
+          
+          AddComboBoxItem(s,
+              GetRealIconIndex_for_DirPath(us2fs(path_for_icon), attrib),
+              indent++,
+              false); // addToList
+          ComboBoxPaths.Add(sumPath);
+        }
+          
+        path.DeleteFrontal(rootPrefixSize);
+        SplitPathToParts(path, pathParts);
+      }
+
+      // it's expected that pathParts.Back() is empty, because _currentFolderPrefix has PathSeparator.
+      unsigned next_Arc_index = 0;
+      int iconIndex_Computer;
+      const UString name_Computer = RootFolder_GetName_Computer(iconIndex_Computer);
+
+      // const bool is_devicePrefix = (sumPath.IsEqualTo("\\\\.\\"));
+
+      if (pathParts.Size() > 1)
+      if (!sumPath.IsEmpty()
+          || pathParts.Size() != 2
+          || pathParts[0] != name_Computer)
+      for (unsigned i = 0; i + 1 < pathParts.Size(); i++)
+      {
+        UString name = pathParts[i];
+        sumPath += name;
+
+        bool isRootDir_inLink = false;
+        if (next_Arc_index < _parentFolders.Size())
+        {
+          const CFolderLink &link = _parentFolders[next_Arc_index];
+          if (link.VirtualPath == sumPath)
+          {
+            isRootDir_inLink = true;
+            next_Arc_index++;
+          }
+        }
+        
+        int iconIndex = -1;
+        DWORD attrib = isRootDir_inLink ?
+            FILE_ATTRIBUTE_ARCHIVE:
+            FILE_ATTRIBUTE_DIRECTORY;
+        if (next_Arc_index == 0
+            || (next_Arc_index == 1 && isRootDir_inLink))
+        {
+          if (i == 0 && NName::IsDevicePath(us2fs(sumPath)))
+          {
+            UString path = name;
+            path.Add_PathSepar();
+            attrib = FILE_ATTRIBUTE_ARCHIVE;
+              // FILE_ATTRIBUTE_DIRECTORY;
+          }
+          else
+          {
+            CFileInfo info;
+            if (info.Find(us2fs(sumPath)))
+              attrib = info.Attrib;
+          }
+          iconIndex = Shell_GetFileInfo_SysIconIndex_for_Path(us2fs(sumPath), attrib);
+        }
+        
+        if (iconIndex < 0)
+          iconIndex = g_Ext_to_Icon_Map.GetIconIndex(attrib, name);
+        // iconIndex = -1; // for debug
+        if (iconIndex < 0 && isRootDir_inLink)
+          iconIndex = 0; // default file
+
+        sumPath.Add_PathSepar();
+
+        ComboBoxPaths.Add(sumPath);
+        if (name.IsEmpty())
+          name.Add_PathSepar();
+        AddComboBoxItem(name, iconIndex, indent++,
+            false); // addToList
+      }
+
+#ifndef UNDER_CE
+
+      {
+        int iconIndex;
+        const UString name = RootFolder_GetName_Documents(iconIndex);
+        // iconIndex = -1; // for debug
+        AddComboBoxItem(name, iconIndex, 0, true);
+      }
+      AddComboBoxItem(name_Computer, iconIndex_Computer, 0, true);
+      {
+        FStringVector driveStrings;
+        MyGetLogicalDriveStrings(driveStrings);
+        FOR_VECTOR (i, driveStrings)
+        {
+          FString s = driveStrings[i];
+          ComboBoxPaths.Add(fs2us(s));
+          int iconIndex2 = GetRealIconIndex_for_DirPath(s, FILE_ATTRIBUTE_DIRECTORY);
+          if (!s.IsEmpty())
+          {
+            const FChar c = s.Back();
+            if (IS_PATH_SEPAR(c))
+              s.DeleteBack();
+          }
+          // iconIndex2 = -1; // for debug
+          AddComboBoxItem(fs2us(s), iconIndex2, 1, false);
+        }
+      }
+      {
+        int iconIndex;
+        const UString name = RootFolder_GetName_Network(iconIndex);
+        AddComboBoxItem(name, iconIndex, 0, true);
+      }
+
+#endif
+    
+      return false;
+    }
+
+    case CBN_SELENDOK:
+    {
+      int index = _headerComboBox.GetCurSel();
+      if (index >= 0)
+      {
+        const UString path = ComboBoxPaths[index];
+        _headerComboBox.SetCurSel(-1);
+        // _headerComboBox.SetText(pass); // it's fix for selecting by mouse.
+        if (BindToPathAndRefresh(path) == 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 = (int)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.IsEqualTo("\\\\.") &&
+          !s.IsEqualTo("\\\\?"))
+      {
+        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.IsEqualTo("\\\\.") &&
+          !focusedName.IsEqualTo("\\\\?"))
+      {
+        const int pos = focusedName.ReverseFind_PathSepar();
+        if (pos >= 0)
+        {
+          parentFolderPrefix = focusedName;
+          parentFolderPrefix.DeleteFrom((unsigned)(pos + 1));
+          focusedName.DeleteFrontal((unsigned)(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(unsigned index)
+{
+  if (index == kParentIndex)
+  {
+    OpenParentFolder();
+    return;
+  }
+  CMyComPtr<IFolderFolder> newFolder;
+  const HRESULT res = _folder->BindToFolder((unsigned)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;
+  Get_ItemIndices_Operated(indices);
+  Int32 realIndex = -1;
+  if (indices.Size() > 1)
+    return;
+  if (indices.Size() == 1)
+    realIndex = (Int32)indices[0];
+
+  if (_folderAltStreams)
+  {
+    CMyComPtr<IFolderFolder> newFolder;
+    _folderAltStreams->BindToAltStreams((UInt32)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((UInt32)realIndex);
+  else
+  {
+    path = GetFsPath();
+    if (!NName::IsDriveRootPath_SuperAllowed(us2fs(path)))
+      if (!path.IsEmpty() && IS_PATH_SEPAR(path.Back()))
+        path.DeleteBack();
+  }
+
+  path.Add_Colon();
+  BindToPathAndRefresh(path);
+  #endif
+}