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; }