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);
CreateSevenZipMenu(menu, operatedIndices, sevenZipContextMenu);
if (g_App.ShowSystemMenu)
CreateSystemMenu(menu, operatedIndices, systemContextMenu);
/*
if (menu.GetItemCount() > 0)
menu.AppendItem(MF_SEPARATOR, 0, (LPCTSTR)0);
*/
int i;
for (i = 0; i < operatedIndices.Size(); i++)
if (IsItemFolder(operatedIndices[i]))
break;
bool allAreFiles = (i == operatedIndices.Size());
LoadFileMenu(menu, menu.GetItemCount(), programMenu,
IsFSFolder(), operatedIndices.Size(), allAreFiles);
}
void CPanel::GetSelectedNames(UStringVector &selectedNames)
{
selectedNames.Clear();
CRecordVector<UInt32> indices;
GetSelectedItemsIndices(indices);
selectedNames.Reserve(indices.Size());
for (int i = 0; i < indices.Size(); i++)
selectedNames.Add(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();
}
HRESULT DecompressArchive(
IInArchive *archive,
const UString &defaultName,
const NWildcard::CCensorNode &wildcardCensor,
const CExtractOptions &options,
IExtractCallbackUI *callback)
{
CRecordVector<UInt32> realIndices;
UInt32 numItems;
RINOK(archive->GetNumberOfItems(&numItems));
for(UInt32 i = 0; i < numItems; i++)
{
UString filePath;
RINOK(GetArchiveItemPath(archive, i, options.DefaultItemName, filePath));
bool isFolder;
RINOK(IsArchiveItemFolder(archive, i, isFolder));
if (!wildcardCensor.CheckPath(filePath, !isFolder))
continue;
realIndices.Add(i);
}
if (realIndices.Size() == 0)
{
callback->ThereAreNoFiles();
return S_OK;
}
CArchiveExtractCallback *extractCallbackSpec = new CArchiveExtractCallback;
CMyComPtr<IArchiveExtractCallback> extractCallback(extractCallbackSpec);
UStringVector removePathParts;
UString outDir = options.OutputDir;
outDir.Replace(L"*", defaultName);
if(!outDir.IsEmpty())
if(!NFile::NDirectory::CreateComplexDirectory(outDir))
{
throw UString(L"Can not create output directory ") + outDir;
}
extractCallbackSpec->Init(
archive,
callback,
options.StdOutMode,
outDir,
options.PathMode,
options.OverwriteMode,
removePathParts,
options.DefaultItemName,
options.ArchiveFileInfo.LastWriteTime,
options.ArchiveFileInfo.Attributes);
HRESULT result = archive->Extract(&realIndices.Front(),
realIndices.Size(), options.TestMode? 1: 0,
extractCallback);
return callback->ExtractResult(result);
}
UString CPanel::GetItemsInfoString(const CRecordVector<UInt32> &indices)
{
UString info;
UInt64 numDirs, numFiles, filesSize, foldersSize;
numDirs = numFiles = filesSize = foldersSize = 0;
int i;
for (i = 0; i < indices.Size(); i++)
{
int index = indices[i];
if (IsItemFolder(index))
{
AddPropValueToSum(_folder, index, kpidSize, foldersSize);
numDirs++;
}
else
{
AddPropValueToSum(_folder, index, kpidSize, filesSize);
numFiles++;
}
}
AddValuePair2(IDS_FOLDERS_COLON, 0x02000321, numDirs, foldersSize, info);
AddValuePair2(IDS_FILES_COLON, 0x02000320, numFiles, filesSize, info);
int numDefined = ((foldersSize != (UInt64)(Int64)-1) && foldersSize != 0) ? 1: 0;
numDefined += ((filesSize != (UInt64)(Int64)-1) && filesSize != 0) ? 1: 0;
if (numDefined == 2)
AddValuePair1(IDS_SIZE_COLON, 0x02000322, filesSize + foldersSize, info);
info += L"\n";
#ifdef _WIN32
info += _currentFolderPrefix;
#else
{
extern const TCHAR * nameWindowToUnix(const TCHAR * lpFileName);
UString tmp = nameWindowToUnix(_currentFolderPrefix);
info += tmp;
}
#endif
for (i = 0; i < indices.Size() && i < kCopyDialog_NumInfoLines - 6; i++)
{
info += L"\n ";
int index = indices[i];
info += GetItemRelPath(index);
if (IsItemFolder(index))
info += WCHAR_PATH_SEPARATOR;
}
if (i != indices.Size())
info += L"\n ...";
return info;
}
void CContentsView::AddToArchive()
{
CRecordVector<UInt32> indices;
GetOperatedItemIndices(indices);
if (!Is_IO_FS_Folder())
{
MessageBoxErrorLang(IDS_OPERATION_IS_NOT_SUPPORTED);
return;
}
if (indices.Size() == 0)
{
MessageBoxErrorLang(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]));
bool fromPrev = (names.Size() > 1);
const UString arcName = CreateArchiveName(names.Front(), fromPrev, false);
HRESULT res = CompressFiles(destCurDirPrefix, arcName, L"",
true, // addExtension
names, false, true, false);
if (res != S_OK)
{
if (destCurDirPrefix.Len() >= MAX_PATH)
MessageBoxErrorLang(IDS_MESSAGE_UNSUPPORTED_OPERATION_FOR_LONG_PATH_FOLDER);
}
// KillSelection();
}
void CApp::CalculateCrc()
{
int srcPanelIndex = GetFocusedPanelIndex();
CPanel &srcPanel = Panels[srcPanelIndex];
if (!srcPanel.IsFsOrDrivesFolder())
{
srcPanel.MessageBoxErrorLang(IDS_OPERATION_IS_NOT_SUPPORTED, 0x03020208);
return;
}
CRecordVector<UInt32> indices;
srcPanel.GetOperatedItemIndices(indices);
if (indices.IsEmpty())
return;
{
CThreadCrc t;
for (int i = 0; i < indices.Size(); i++)
t.Enumerator.FileNames.Add(us2fs(srcPanel.GetItemRelPath(indices[i])));
t.Enumerator.BasePrefix = us2fs(srcPanel.GetFsPath());
t.Enumerator.FlatMode = GetFlatMode();
t.ProgressDialog.ShowCompressionInfo = false;
UString title = LangString(IDS_CHECKSUM_CALCULATING, 0x03020710);
t.ProgressDialog.MainWindow = _window;
t.ProgressDialog.MainTitle = LangString(IDS_APP_TITLE, 0x03000000);
t.ProgressDialog.MainAddTitle = title + UString(L' ');
if (t.Create(title, _window) != S_OK)
return;
}
RefreshTitleAlways();
}
HRESULT CThreadCopyFrom::ProcessVirt()
{
UStringVector fileNames;
CRecordVector<const wchar_t *> fileNamePointers;
fileNames.Add(Name);
fileNamePointers.Add(fileNames[0]);
return FolderOperations->CopyFrom(PathPrefix, &fileNamePointers.Front(), fileNamePointers.Size(), UpdateCallback);
};
void CPanel::CreateSevenZipMenu(HMENU menuSpec,
const CRecordVector<UInt32> &operatedIndices,
CMyComPtr<IContextMenu> &sevenZipContextMenu)
{
sevenZipContextMenu.Release();
CMenu menu;
menu.Attach(menuSpec);
// CMenuDestroyer menuDestroyer(menu);
// menu.CreatePopup();
bool sevenZipMenuCreated = false;
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 = _currentFolderPrefix;
UStringVector names;
int i;
for(i = 0; i < operatedIndices.Size(); i++)
names.Add(currentFolderUnicode + GetItemRelPath(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);
sevenZipMenuCreated = (HRESULT_SEVERITY(res) == SEVERITY_SUCCESS);
if (sevenZipMenuCreated)
sevenZipContextMenu = contextMenu;
// int code = HRESULT_CODE(res);
// int nextItemID = code;
}
}
}
void CPanel::DeleteItemsInternal(CRecordVector<UInt32> &indices)
{
CMyComPtr<IFolderOperations> folderOperations;
if (_folder.QueryInterface(IID_IFolderOperations, &folderOperations) != S_OK)
{
MessageBoxErrorForUpdate(E_NOINTERFACE, IDS_ERROR_DELETING, 0x03020217);
return;
}
UString title;
UString message;
if (indices.Size() == 1)
{
int index = indices[0];
const UString itemName = GetItemRelPath(index);
if (IsItemFolder(index))
{
title = LangString(IDS_CONFIRM_FOLDER_DELETE, 0x03020211);
message = MyFormatNew(IDS_WANT_TO_DELETE_FOLDER, 0x03020214, itemName);
}
else
{
title = LangString(IDS_CONFIRM_FILE_DELETE, 0x03020210);
message = MyFormatNew(IDS_WANT_TO_DELETE_FILE, 0x03020213, itemName);
}
}
else
{
title = LangString(IDS_CONFIRM_ITEMS_DELETE, 0x03020212);
message = MyFormatNew(IDS_WANT_TO_DELETE_ITEMS, 0x03020215,
NumberToString(indices.Size()));
}
if (::MessageBoxW(GetParent(), message, title, MB_OKCANCEL | MB_ICONQUESTION) != IDOK)
return;
{
CThreadFolderOperations op(FOLDER_TYPE_DELETE);
op.FolderOperations = folderOperations;
op.Indices = indices;
op.DoOperation(*this,
LangString(IDS_DELETING, 0x03020216),
LangString(IDS_ERROR_DELETING, 0x03020217));
}
RefreshTitleAlways();
}
HRESULT CPanelCopyThread::ProcessVirt()
{
/*
CMyComPtr<IFolderSetReplaceAltStreamCharsMode> iReplace;
FolderOperations.QueryInterface(IID_IFolderSetReplaceAltStreamCharsMode, &iReplace);
if (iReplace)
{
RINOK(iReplace->SetReplaceAltStreamCharsMode(ReplaceAltStreamChars ? 1 : 0));
}
*/
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;
Result = archiveFolder->Extract(&Indices.Front(), Indices.Size(),
BoolToInt(options->includeAltStreams),
BoolToInt(options->replaceAltStreamChars),
pathMode, NExtract::NOverwriteMode::kAsk,
options->folder, BoolToInt(true), extractCallback2);
}
else
Result = FolderOperations->CopyTo(
BoolToInt(options->moveMode),
&Indices.Front(), Indices.Size(),
BoolToInt(options->includeAltStreams),
BoolToInt(options->replaceAltStreamChars),
options->folder, ExtractCallback);
if (Result == S_OK && !ExtractCallbackSpec->ThereAreMessageErrors &&
(!options->hashMethods.IsEmpty() || options->testMode))
{
CProgressMessageBoxPair &pair = GetMessagePair(false); // GetMessagePair(ExtractCallbackSpec->Hash.NumErrors != 0);
AddHashBundleRes(pair.Message, Hash, FirstFilePath);
}
return Result;
}
UInt64 GetNumberOfVolumes(UInt64 size, CRecordVector<UInt64> &volSizes)
{
if (size == 0 || volSizes.Size() == 0)
return 1;
UInt64 numVolumes = 0;
for (int i = 0; i < volSizes.Size(); i++)
{
UInt64 volSize = volSizes[i];
numVolumes++;
if (volSize >= size)
return numVolumes;
size -= volSize;
}
UInt64 volSize = volSizes.Back();
if (volSize == 0)
return (UInt64)(Int64)-1;
return numVolumes + (size - 1) / volSize + 1;
}
static void RemoveOneItem(CRecordVector<UInt64> &src, UInt32 item)
{
for (int i = 0; i < src.Size(); i++)
if (src[i] == item)
{
src.Delete(i);
return;
}
}
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 += L"\n ";
int index = indices[i];
info += GetItemRelPath(index);
if (IsItem_Folder(index))
info.Add_PathSepar();
}
if (i != indices.Size())
info += L"\n ...";
return info;
}
static void InsertToHead(CRecordVector<UInt64> &dest, UInt32 item)
{
for (int i = 0; i < dest.Size(); i++)
if (dest[i] == item)
{
dest.Delete(i);
break;
}
dest.Insert(0, item);
}
void CPanel::OpenSelectedItems(bool tryInternal)
{
CRecordVector<UInt32> indices;
GetOperatedItemIndices(indices);
if (indices.Size() > 20)
{
MessageBoxErrorLang(IDS_TOO_MANY_ITEMS, 0x02000606);
return;
}
int focusedItem = _listView.GetFocusedItem();
if (focusedItem >= 0)
{
int realIndex = GetRealItemIndex(focusedItem);
if (realIndex == kParentIndex && (tryInternal || indices.Size() == 0) &&
_listView.GetItemState(focusedItem, LVIS_SELECTED) == LVIS_SELECTED)
indices.Insert(0, realIndex);
}
bool dirIsStarted = false;
for (int i = 0; i < indices.Size(); i++)
{
UInt32 index = indices[i];
// CFileInfo &aFile = m_Files[index];
if (IsItemFolder(index))
{
if (!dirIsStarted)
{
if (tryInternal)
{
OpenFolder(index);
dirIsStarted = true;
break;
}
else
OpenFolderExternal(index);
}
}
else
OpenItem(index, (tryInternal && indices.Size() == 1), true);
}
}
static void CopyOneItem(CRecordVector<UInt64> &src,
CRecordVector<UInt64> &dest, UInt32 item)
{
for (int i = 0; i < src.Size(); i++)
if (src[i] == item)
{
dest.Add(item);
src.Delete(i);
return;
}
}
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;
}
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(UString(), -1, true, UStringVector());
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 += L':';
BindToPathAndRefresh(path);
#endif
}
void CApp::DiffFiles()
{
const CPanel &panel = GetFocusedPanel();
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];
path1 = panel.GetItemFullPath(indices[0]);
const UString relPath = panel.GetItemRelPath(indices[0]);
CRecordVector<UInt32> indices2;
destPanel.GetSelectedItemsIndices(indices2);
if (indices2.Size() == 1)
path2 = destPanel.GetItemFullPath(indices2[0]);
else
path2 = destPanel._currentFolderPrefix + relPath;
}
else
return;
UString command;
ReadRegDiff(command);
if (command.IsEmpty())
return;
UString param = GetQuotedString(path1) + L' ' + GetQuotedString(path2);
HRESULT res = MyCreateProcess(command, param);
if (res == SZ_OK)
return;
::MessageBoxW(_window, LangString(IDS_CANNOT_START_EDITOR, 0x03020282), L"7-Zip", MB_OK | MB_ICONSTOP);
}
HRESULT CFolderOutStream::Unsupported()
{
while(m_CurrentIndex < m_ExtractStatuses->Size())
{
HRESULT result = OpenFile();
if (result != S_FALSE && result != S_OK)
return result;
m_RealOutStream.Release();
RINOK(m_ExtractCallback->SetOperationResult(NExtract::NOperationResult::kUnSupportedMethod));
m_CurrentIndex++;
}
return S_OK;
}
HRESULT SetProperties(IUnknown *unknown, const CObjectVector<CProperty> &properties)
{
if (properties.IsEmpty())
return S_OK;
CMyComPtr<ISetProperties> setProperties;
unknown->QueryInterface(IID_ISetProperties, (void **)&setProperties);
if (!setProperties)
return S_OK;
UStringVector realNames;
CPropVariant *values = new CPropVariant[properties.Size()];
try
{
int i;
for(i = 0; i < properties.Size(); i++)
{
const CProperty &property = properties[i];
NCOM::CPropVariant propVariant;
UString name = property.Name;
if (property.Value.IsEmpty())
{
if (!name.IsEmpty())
{
wchar_t c = name.Back();
if (c == L'-')
propVariant = false;
else if (c == L'+')
propVariant = true;
if (propVariant.vt != VT_EMPTY)
name.DeleteBack();
}
}
else
ParseNumberString(property.Value, propVariant);
realNames.Add(name);
values[i] = propVariant;
}
CRecordVector<const wchar_t *> names;
for(i = 0; i < realNames.Size(); i++)
names.Add((const wchar_t *)realNames[i]);
RINOK(setProperties->SetProperties(&names.Front(), values, names.Size()));
}
catch(...)
{
delete []values;
throw;
}
delete []values;
return S_OK;
}
HRESULT CAgent::CreateFolder(
const wchar_t *newArchiveName,
const wchar_t *folderName,
IFolderArchiveUpdateCallback *updateCallback100)
{
if (!CanUpdate())
return E_NOTIMPL;
CUpdateCallbackAgent updateCallbackAgent;
updateCallbackAgent.SetCallback(updateCallback100);
CArchiveUpdateCallback *updateCallbackSpec = new CArchiveUpdateCallback;
CMyComPtr<IArchiveUpdateCallback> updateCallback(updateCallbackSpec);
CRecordVector<CUpdatePair2> updatePairs;
UInt32 numItemsInArchive;
RINOK(GetArchive()->GetNumberOfItems(&numItemsInArchive));
for (UInt32 i = 0; i < numItemsInArchive; i++)
{
CUpdatePair2 up2;
up2.NewData = up2.NewProps = false;
up2.IsAnti = false; // check it.
up2.ArcIndex = i;
updatePairs.Add(up2);
}
CUpdatePair2 up2;
up2.NewData = up2.NewProps = true;
up2.IsAnti = false;
up2.DirIndex = 0;
updatePairs.Add(up2);
updatePairs.ReserveDown();
CDirItems dirItems;
CDirItem di;
di.Attrib = FILE_ATTRIBUTE_DIRECTORY;
di.Size = 0;
di.Name = _agentFolder->_proxyFolderItem->GetFullPathPrefix() + folderName;
FILETIME ft;
NTime::GetCurUtcFileTime(ft);
di.CTime = di.ATime = di.MTime = ft;
dirItems.Items.Add(di);
updateCallbackSpec->Callback = &updateCallbackAgent;
updateCallbackSpec->DirItems = &dirItems;
updateCallbackSpec->UpdatePairs = &updatePairs;
updateCallbackSpec->Archive = GetArchive();
return CommonUpdate(newArchiveName, updatePairs.Size(), updateCallback);
}
void Process()
{
try
{
CProgressCloser closer(ProgressDialog);
Result = FolderOperations->CopyFrom(
MoveMode,
FolderPrefix,
&FileNamePointers.Front(),
FileNamePointers.Size(),
UpdateCallback);
}
catch(...) { Result = E_FAIL; }
}
void CPanel::OnRefreshStatusBar()
{
CRecordVector<UINT32> indices;
GetOperatedItemIndices(indices);
_statusBar.SetText(0, MyFormatNew(IDS_N_SELECTED_ITEMS, 0x02000301, NumberToString(indices.Size())));
UString selectSizeString;
if (indices.Size() > 0)
{
UInt64 totalSize = 0;
for (int i = 0; i < indices.Size(); i++)
totalSize += GetItemSize(indices[i]);
selectSizeString = ConvertSizeToString(totalSize);
}
_statusBar.SetText(1, selectSizeString);
int focusedItem = _listView.GetFocusedItem();
UString sizeString;
UString dateString;
if (focusedItem >= 0 && _listView.GetSelectedCount() > 0)
{
int realIndex = GetRealItemIndex(focusedItem);
if (realIndex != kParentIndex)
{
sizeString = ConvertSizeToString(GetItemSize(realIndex));
NCOM::CPropVariant prop;
if (_folder->GetProperty(realIndex, kpidMTime, &prop) == S_OK)
dateString = ConvertPropertyToString(prop, kpidMTime, false);
}
}
_statusBar.SetText(2, sizeString);
_statusBar.SetText(3, dateString);
// _statusBar.SetText(4, nameString);
// _statusBar2.SetText(1, MyFormatNew(L"{0} bytes", NumberToStringW(totalSize)));
}
static HRESULT SetOutProperties(IOutFolderArchive *outArchive, UINT32 method)
{
CMyComPtr<ISetProperties> setProperties;
if (outArchive->QueryInterface(IID_ISetProperties, (void **)&setProperties) == S_OK)
{
UStringVector realNames;
realNames.Add(UString(L"x"));
NCOM::CPropVariant value = (UInt32)method;
CRecordVector<const wchar_t *> names;
for (int i = 0; i < realNames.Size(); i++)
names.Add(realNames[i]);
RINOK(setProperties->SetProperties(&names.Front(), &value, names.Size()));
}
return S_OK;
}
void UpdateProduce(
const CRecordVector<CUpdatePair> &updatePairs,
const CActionSet &actionSet,
CRecordVector<CUpdatePair2> &operationChain,
IUpdateProduceCallback *callback)
{
for (int i = 0; i < updatePairs.Size(); i++)
{
const CUpdatePair &pair = updatePairs[i];
CUpdatePair2 up2;
up2.IsAnti = false;
up2.DirIndex = pair.DirIndex;
up2.ArcIndex = pair.ArcIndex;
up2.NewData = up2.NewProps = true;
switch(actionSet.StateActions[pair.State])
{
case NPairAction::kIgnore:
/*
if (pair.State != NPairState::kOnlyOnDisk)
IgnoreArchiveItem(m_ArchiveItems[pair.ArcIndex]);
// cout << "deleting";
*/
if (callback)
callback->ShowDeleteFile(pair.ArcIndex);
continue;
case NPairAction::kCopy:
if (pair.State == NPairState::kOnlyOnDisk)
throw kUpdateActionSetCollision;
up2.NewData = up2.NewProps = false;
break;
case NPairAction::kCompress:
if (pair.State == NPairState::kOnlyInArchive ||
pair.State == NPairState::kNotMasked)
throw kUpdateActionSetCollision;
break;
case NPairAction::kCompressAsAnti:
up2.IsAnti = true;
break;
}
operationChain.Add(up2);
}
operationChain.ReserveDown();
}
void CPanel::GetSelectedItemsIndices(CRecordVector<UInt32> &indices) const
{
indices.Clear();
/*
int itemIndex = -1;
while ((itemIndex = _listView.GetNextItem(itemIndex, LVNI_SELECTED)) != -1)
{
LPARAM param;
if (_listView.GetItemParam(itemIndex, param))
indices.Add(param);
}
*/
for (int i = 0; i < _selectedStatusVector.Size(); i++)
if (_selectedStatusVector[i])
indices.Add(i);
HeapSort(&indices.Front(), indices.Size());
}
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;
}
HRESULT CFolderOutStream::WriteEmptyFiles()
{
if (m_FileIsOpen)
return S_OK;
for (; m_CurrentIndex < m_ExtractStatuses->Size(); m_CurrentIndex++)
{
const CMvItem &mvItem = m_Database->Items[m_StartIndex + m_CurrentIndex];
const CItem &item = m_Database->Volumes[mvItem.VolumeIndex].Items[mvItem.ItemIndex];
UInt64 fileSize = item.Size;
if (fileSize != 0)
return S_OK;
HRESULT result = OpenFile();
m_RealOutStream.Release();
RINOK(result);
RINOK(m_ExtractCallback->SetOperationResult(NExtract::NOperationResult::kOK));
}
return S_OK;
}
HRESULT CThreadFolderOperations::ProcessVirt()
{
NCOM::CComInitializer comInitializer;
switch(OpType)
{
case FOLDER_TYPE_CREATE_FOLDER:
Result = FolderOperations->CreateFolder(Name, UpdateCallback);
break;
case FOLDER_TYPE_DELETE:
Result = FolderOperations->Delete(&Indices.Front(), Indices.Size(), UpdateCallback);
break;
case FOLDER_TYPE_RENAME:
Result = FolderOperations->Rename(Index, Name, UpdateCallback);
break;
default:
Result = E_FAIL;
}
return Result;
}
