HRESULT UpdateGUI(
CCodecs *codecs,
const NWildcard::CCensor &censor,
CUpdateOptions &options,
bool showDialog,
CUpdateErrorInfo &errorInfo,
COpenCallbackGUI *openCallback,
CUpdateCallbackGUI *callback)
{
if (showDialog)
{
RINOK(ShowDialog(codecs, censor, options, callback));
}
if (options.SfxMode && options.SfxModule.IsEmpty())
options.SfxModule = kDefaultSfxModule;
CThreadUpdating tu;
tu.codecs = codecs;
tu.UpdateCallbackGUI = callback;
tu.UpdateCallbackGUI->Init();
tu.WildcardCensor = &censor;
tu.Options = &options;
tu.OpenCallback = openCallback;
tu.ErrorInfo = &errorInfo;
NWindows::CThread thread;
RINOK(thread.Create(CThreadUpdating::MyThreadFunction, &tu))
tu.UpdateCallbackGUI->StartProgressDialog(LangString(IDS_PROGRESS_COMPRESSING, 0x02000DC0));
return tu.Result;
}
HRESULT CPanel::CopyFrom(bool moveMode, const UString &folderPrefix, const UStringVector &filePaths,
bool showErrorMessages, UStringVector *messages)
{
CMyComPtr<IFolderOperations> folderOperations;
_folder.QueryInterface(IID_IFolderOperations, &folderOperations);
HRESULT res;
if (!folderOperations)
res = E_NOINTERFACE;
else
{
CThreadUpdate updater;
updater.MoveMode = moveMode;
updater.UpdateCallbackSpec = new CUpdateCallback100Imp;
updater.UpdateCallback = updater.UpdateCallbackSpec;
updater.UpdateCallbackSpec->ProgressDialog = &updater.ProgressDialog;
UString title = LangString(IDS_COPYING);
UString progressWindowTitle = L"7-Zip"; // LangString(IDS_APP_TITLE);
updater.ProgressDialog.MainWindow = GetParent();
updater.ProgressDialog.MainTitle = progressWindowTitle;
updater.ProgressDialog.MainAddTitle = title + UString(L' ');
updater.UpdateCallbackSpec->Init(false, L"");
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 != 0)
*messages = updater.ProgressDialog.Sync.Messages;
res = updater.Result;
}
if (res == E_NOINTERFACE)
{
UString errorMessage = LangString(IDS_OPERATION_IS_NOT_SUPPORTED);
if (showErrorMessages)
MessageBox(errorMessage);
else if (messages != 0)
messages->Add(errorMessage);
return E_ABORT;
}
RefreshTitleAlways();
return res;
}
void StopWaitClose()
{
ExitThread = true;
if (OutStreamSpec != 0)
OutStreamSpec->StopWriting(E_ABORT);
if (CompressEvent.IsCreated())
CompressEvent.Set();
Thread.Wait();
Thread.Close();
}
void testCProgressDialog()
{
CProgressDialog ProgressDialog;
CThreadProgressDialog benchmarker;
benchmarker.ProgressDialog = &ProgressDialog;
NWindows::CThread thread;
thread.Create(CThreadProgressDialog::MyThreadFunction, &benchmarker);
// void StartProgressDialog(const UString &title)
int ret = ProgressDialog.Create(L"testCProgressDialog", 0);
if (ret == IDOK) myErrorMsg(wxT("CProgressDialog => IDOK"));
else if (ret == IDCANCEL) myErrorMsg(wxT("CProgressDialog => IDCANCEL"));
else myErrorMsg(wxT("CProgressDialog => ?"));
}
HRESULT ExtractArchive(CCodecs *codecs,const UString &fileName, const UString &destFolder,
bool showProgress, bool &isCorrupt, UString &errorMessage)
{
isCorrupt = false;
CThreadExtracting t;
t.Codecs = codecs;
t.FileName = fileName;
t.DestFolder = destFolder;
t.ExtractCallbackSpec = new CExtractCallbackImp;
t.ExtractCallback = t.ExtractCallbackSpec;
#ifndef _NO_PROGRESS
t.ShowProgress = showProgress;
if (showProgress)
{
NWindows::CThread thread;
RINOK(thread.Create(CThreadExtracting::MyThreadFunction, &t));
UString title;
#ifdef LANG
title = LangLoadString(IDS_PROGRESS_EXTRACTING, 0x02000890);
#else
title = NWindows::MyLoadStringW(IDS_PROGRESS_EXTRACTING);
#endif
t.ExtractCallbackSpec->StartProgressDialog(title);
}
else
#endif
{
t.Process();
}
errorMessage = t.ErrorMessage;
if (errorMessage.IsEmpty())
errorMessage = t.ExtractCallbackSpec->_message;
isCorrupt = t.ExtractCallbackSpec->_isCorrupt;
return t.Result;
}
HRESULT ExtractArchive(CCodecs *codecs, const FString &fileName, const FString &destFolder,
bool showProgress, bool &isCorrupt, UString &errorMessage)
{
isCorrupt = false;
CThreadExtracting t;
t.Codecs = codecs;
t.FileName = fileName;
t.DestFolder = destFolder;
t.ExtractCallbackSpec = new CExtractCallbackImp;
t.ExtractCallback = t.ExtractCallbackSpec;
#ifndef _NO_PROGRESS
if (showProgress)
{
t.ExtractCallbackSpec->ProgressDialog.IconID = IDI_ICON;
NWindows::CThread thread;
RINOK(thread.Create(CThreadExtracting::MyThreadFunction, &t));
UString title;
LangString(IDS_PROGRESS_EXTRACTING, title);
t.ExtractCallbackSpec->StartProgressDialog(title, thread);
}
else
#endif
{
t.Process2();
}
errorMessage = t.ErrorMessage;
if (errorMessage.IsEmpty())
errorMessage = t.ExtractCallbackSpec->_message;
isCorrupt = t.ExtractCallbackSpec->_isCorrupt;
return t.Result;
}
HRes CreateThread() { return Thread.Create(CoderThread, this); }
void CPanel::OpenItemInArchive(int index, bool tryInternal, bool tryExternal, bool editMode)
{
const UString name = GetItemName(index);
if (IsNameVirus(name))
{
MessageBoxErrorLang(IDS_VIRUS, 0x03020284);
return;
}
CMyComPtr<IFolderOperations> folderOperations;
if (_folder.QueryInterface(IID_IFolderOperations, &folderOperations) != S_OK)
{
MessageBoxErrorLang(IDS_OPERATION_IS_NOT_SUPPORTED, 0x03020208);
return;
}
bool tryAsArchive = tryInternal && (!tryExternal || !DoItemAlwaysStart(name));
UString fullVirtPath = _currentFolderPrefix + name;
NFile::NDirectory::CTempDirectoryW tempDirectory;
tempDirectory.Create(kTempDirPrefix);
UString tempDir = tempDirectory.GetPath();
UString tempDirNorm = tempDir;
NFile::NName::NormalizeDirPathPrefix(tempDirNorm);
UString tempFilePath = tempDirNorm + GetCorrectFsPath(name);
CTempFileInfo tempFileInfo;
tempFileInfo.ItemName = name;
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)
{
bool encrypted;
if (OpenItemAsArchive(subStream, tempFileInfo, fullVirtPath, encrypted) == S_OK)
{
tempDirectory.DisableDeleting();
RefreshListCtrl();
return;
}
}
}
}
}
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;
}
HRESULT result = CopyTo(indices, tempDirNorm, false, true, &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)
MessageBoxError(result);
return;
}
if (tryAsArchive)
{
bool encrypted;
if (OpenItemAsArchive(NULL, tempFileInfo, fullVirtPath, encrypted) == S_OK)
{
tempDirectory.DisableDeleting();
RefreshListCtrl();
return;
}
}
CMyAutoPtr<CTmpProcessInfo> tmpProcessInfoPtr(new CTmpProcessInfo());
CTmpProcessInfo *tmpProcessInfo = tmpProcessInfoPtr.get();
tmpProcessInfo->FolderPath = tempDir;
tmpProcessInfo->FilePath = tempFilePath;
tmpProcessInfo->NeedDelete = true;
tmpProcessInfo->UsePassword = usePassword;
tmpProcessInfo->Password = password;
if (!tmpProcessInfo->FileInfo.Find(tempFilePath))
return;
CTmpProcessInfoRelease tmpProcessInfoRelease(*tmpProcessInfo);
if (!tryExternal)
return;
CProcess process;
HRESULT res;
if (editMode)
res = StartEditApplication(tempFilePath, (HWND)*this, process);
else
res = StartApplication(tempDirNorm, tempFilePath, (HWND)*this, process);
if ((HANDLE)process == 0)
return;
tmpProcessInfo->Window = (HWND)(*this);
tmpProcessInfo->FullPathFolderPrefix = _currentFolderPrefix;
tmpProcessInfo->ItemName = name;
tmpProcessInfo->ProcessHandle = process.Detach();
NWindows::CThread thread;
if (thread.Create(MyThreadFunction, tmpProcessInfo) != S_OK)
throw 271824;
tempDirectory.DisableDeleting();
tmpProcessInfoPtr.release();
tmpProcessInfoRelease._needDelete = false;
}
HRESULT OpenFileFolderPlugin(
const UString &path,
HMODULE *module,
IFolderFolder **resultFolder,
HWND parentWindow,
bool &encrypted, UString &password)
{
CObjectVector<CPluginInfo> plugins;
ReadFileFolderPluginInfoList(plugins);
UString extension;
UString name, pureName, dot;
if(!NFile::NDirectory::GetOnlyName(path, name))
return E_FAIL;
NFile::NName::SplitNameToPureNameAndExtension(name, pureName, dot, extension);
int slashPos = path.ReverseFind(WCHAR_PATH_SEPARATOR);
UString dirPrefix;
UString fileName;
if (slashPos >= 0)
{
dirPrefix = path.Left(slashPos + 1);
fileName = path.Mid(slashPos + 1);
}
else
fileName = path;
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);
}
}
}
}
for (int i = 0; i < plugins.Size(); i++)
{
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;
t.OpenCallbackSpec->LoadFileInfo(dirPrefix, fileName);
t.Path = path;
UString progressTitle = LangString(IDS_OPENNING, 0x03020283);
t.OpenCallbackSpec->ProgressDialog.MainWindow = parentWindow;
t.OpenCallbackSpec->ProgressDialog.MainTitle = LangString(IDS_APP_TITLE, 0x03000000);
t.OpenCallbackSpec->ProgressDialog.MainAddTitle = progressTitle + UString(L" ");
NWindows::CThread thread;
if (thread.Create(CThreadArchiveOpen::MyThreadFunction, &t) != S_OK)
throw 271824;
t.OpenCallbackSpec->StartProgressDialog(progressTitle);
if (t.Result == E_ABORT)
return t.Result;
if (t.Result == S_OK)
{
// if (openCallbackSpec->PasswordWasAsked)
{
encrypted = t.OpenCallbackSpec->PasswordIsDefined;
password = t.OpenCallbackSpec->Password;
}
*module = library.Detach();
*resultFolder = t.Folder.Detach();
return S_OK;
}
if (t.Result != S_FALSE)
return t.Result;
}
return S_FALSE;
}
HRes CInMemStreamMt::StartReadThread()
{
// _stopReading = false;
NWindows::CThread Thread;
return Thread.Create(CoderThread, this);
}
HRESULT ExtractGUI(
CCodecs *codecs,
const CIntVector &formatIndices,
UStringVector &archivePaths,
UStringVector &archivePathsFull,
const NWildcard::CCensorNode &wildcardCensor,
CExtractOptions &options,
bool showDialog,
CExtractCallbackImp *extractCallback)
{
CThreadExtracting extracter;
extracter.codecs = codecs;
extracter.FormatIndices = formatIndices;
if (!options.TestMode)
{
UString outputDir = options.OutputDir;
if (outputDir.IsEmpty())
NFile::NDirectory::MyGetCurrentDirectory(outputDir);
if (showDialog)
{
CExtractDialog dialog;
if (!NFile::NDirectory::MyGetFullPathName(outputDir, dialog.DirectoryPath))
{
ShowErrorMessage(kIncorrectOutDir);
return E_FAIL;
}
NFile::NName::NormalizeDirPathPrefix(dialog.DirectoryPath);
// dialog.OverwriteMode = options.OverwriteMode;
// dialog.PathMode = options.PathMode;
if(dialog.Create(0) != IDOK)
return E_ABORT;
outputDir = dialog.DirectoryPath;
options.OverwriteMode = dialog.OverwriteMode;
options.PathMode = dialog.PathMode;
#ifndef _SFX
extractCallback->Password = dialog.Password;
extractCallback->PasswordIsDefined = !dialog.Password.IsEmpty();
#endif
}
if (!NFile::NDirectory::MyGetFullPathName(outputDir, options.OutputDir))
{
ShowErrorMessage(kIncorrectOutDir);
return E_FAIL;
}
NFile::NName::NormalizeDirPathPrefix(options.OutputDir);
/*
if(!NFile::NDirectory::CreateComplexDirectory(options.OutputDir))
{
UString s = GetUnicodeString(NError::MyFormatMessage(GetLastError()));
UString s2 = MyFormatNew(IDS_CANNOT_CREATE_FOLDER,
#ifdef LANG
0x02000603,
#endif
options.OutputDir);
MyMessageBox(s2 + UString(L"\n") + s);
return E_FAIL;
}
*/
}
UString title = LangStringSpec(options.TestMode ? IDS_PROGRESS_TESTING : IDS_PROGRESS_EXTRACTING,
options.TestMode ? 0x02000F90: 0x02000890);
extracter.ExtractCallbackSpec = extractCallback;
extracter.ExtractCallback = extractCallback;
extracter.ExtractCallbackSpec->Init();
extracter.ArchivePaths = &archivePaths;
extracter.ArchivePathsFull = &archivePathsFull;
extracter.WildcardCensor = &wildcardCensor;
extracter.Options = &options;
NWindows::CThread thread;
RINOK(thread.Create(CThreadExtracting::MyThreadFunction, &extracter));
extracter.ExtractCallbackSpec->StartProgressDialog(title);
if (extracter.Result == S_OK && options.TestMode &&
extracter.ExtractCallbackSpec->Messages.IsEmpty() &&
extracter.ExtractCallbackSpec->NumArchiveErrors == 0)
{
#ifndef _SFX
UString s;
AddValuePair(IDS_ARCHIVES_COLON, 0x02000324, extracter.Stat.NumArchives, s);
AddValuePair(IDS_FOLDERS_COLON, 0x02000321, extracter.Stat.NumFolders, s);
AddValuePair(IDS_FILES_COLON, 0x02000320, extracter.Stat.NumFiles, s);
AddSizePair(IDS_SIZE_COLON, 0x02000322, extracter.Stat.UnpackSize, s);
AddSizePair(IDS_COMPRESSED_COLON, 0x02000323, extracter.Stat.PackSize, s);
s += L"\n";
s += LangString(IDS_MESSAGE_NO_ERRORS, 0x02000608);
MessageBoxW(0, s, LangString(IDS_PROGRESS_TESTING, 0x02000F90), 0);
#endif
}
if (extracter.Result != S_OK)
if (!extracter.ErrorMessage.IsEmpty())
throw extracter.ErrorMessage;
return extracter.Result;
}
HRESULT OpenFileFolderPlugin(
IInStream *inStream,
const FString &path,
const UString &arcFormat,
HMODULE *module,
IFolderFolder **resultFolder,
HWND parentWindow,
bool &encrypted, UString &password)
{
#ifdef _WIN32
CObjectVector<CPluginInfo> plugins;
ReadFileFolderPluginInfoList(plugins);
#endif
FString extension, name, pureName, dot;
int slashPos = path.ReverseFind(FCHAR_PATH_SEPARATOR);
FString dirPrefix;
FString fileName;
if (slashPos >= 0)
{
dirPrefix.SetFrom(path, slashPos + 1);
fileName = path.Ptr(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);
}
}
}
}
*/
#ifdef _WIN32
FOR_VECTOR (i, plugins)
{
const CPluginInfo &plugin = plugins[i];
if (!plugin.ClassIDDefined)
continue;
#endif
CPluginLibrary library;
CThreadArchiveOpen t;
#ifdef _WIN32
if (plugin.FilePath.IsEmpty())
t.FolderManager = new CArchiveFolderManager;
else if (library.LoadAndCreateManager(plugin.FilePath, plugin.ClassID, &t.FolderManager) != S_OK)
continue;
#else
t.FolderManager = new CArchiveFolderManager;
#endif
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
t.OpenCallbackSpec->LoadFileInfo(dirPrefix, fileName);
t.InStream = inStream;
t.Path = fs2us(path);
t.ArcFormat = arcFormat;
UString progressTitle = LangString(IDS_OPENNING);
t.OpenCallbackSpec->ProgressDialog.MainWindow = parentWindow;
t.OpenCallbackSpec->ProgressDialog.MainTitle = L"7-Zip"; // LangString(IDS_APP_TITLE);
t.OpenCallbackSpec->ProgressDialog.MainAddTitle = progressTitle + L' ';
// FIXME t.OpenCallbackSpec->ProgressDialog.WaitMode = true;
{
NWindows::CThread thread;
RINOK(thread.Create(CThreadArchiveOpen::MyThreadFunction, &t));
t.OpenCallbackSpec->StartProgressDialog(progressTitle, thread);
}
if (t.Result == E_ABORT)
return t.Result;
encrypted = t.OpenCallbackSpec->PasswordIsDefined;
if (t.Result == S_OK)
{
// if (openCallbackSpec->PasswordWasAsked)
{
password = t.OpenCallbackSpec->Password;
}
*module = library.Detach();
*resultFolder = t.Folder.Detach();
return S_OK;
}
if (t.Result != S_FALSE)
return t.Result;
#ifdef _WIN32
}
#endif
return S_FALSE;
}
void CApp::Combine()
{
int srcPanelIndex = GetFocusedPanelIndex();
CPanel &srcPanel = Panels[srcPanelIndex];
if (!srcPanel.IsFSFolder())
{
srcPanel.MessageBox(LangString(IDS_OPERATION_IS_NOT_SUPPORTED, 0x03020208));
return;
}
CRecordVector<UInt32> indices;
srcPanel.GetOperatedItemIndices(indices);
if (indices.IsEmpty())
return;
int index = indices[0];
if (indices.Size() != 1 || srcPanel.IsItemFolder(index))
{
srcPanel.MessageBox(LangString(IDS_COMBINE_SELECT_ONE_FILE, 0x03020620));
return;
}
const UString itemName = srcPanel.GetItemName(index);
UString srcPath = srcPanel._currentFolderPrefix + srcPanel.GetItemPrefix(index);
UString path = srcPath;
int destPanelIndex = (NumPanels <= 1) ? srcPanelIndex : (1 - srcPanelIndex);
CPanel &destPanel = Panels[destPanelIndex];
if (NumPanels > 1)
if (destPanel.IsFSFolder())
path = destPanel._currentFolderPrefix;
CCopyDialog copyDialog;
copyDialog.Value = path;
copyDialog.Title = LangString(IDS_COMBINE, 0x03020600);
copyDialog.Title += ' ';
copyDialog.Title += srcPanel.GetItemRelPath(index);
copyDialog.Static = LangString(IDS_COMBINE_TO, 0x03020601);;
if (copyDialog.Create(srcPanel.GetParent()) == IDCANCEL)
return;
CThreadCombine combiner;
// combiner.Panel = this;
{
CProgressDialog progressDialog;
combiner.ProgressDialog = &progressDialog;
UString progressWindowTitle = LangString(IDS_APP_TITLE, 0x03000000);
UString title = LangString(IDS_COMBINING, 0x03020610);
progressDialog.MainWindow = _window;
progressDialog.MainTitle = progressWindowTitle;
progressDialog.MainAddTitle = title + UString(L" ");
path = copyDialog.Value;
NFile::NName::NormalizeDirPathPrefix(path);
if (!NFile::NDirectory::CreateComplexDirectory(path))
{
srcPanel.MessageBoxMyError(MyFormatNew(IDS_CANNOT_CREATE_FOLDER, 0x02000603, path));
return;
}
combiner.InputDirPrefix = srcPath;
combiner.FirstVolumeName = itemName;
combiner.OutputDirPrefix = path;
// CPanel::CDisableTimerProcessing disableTimerProcessing1(srcPanel);
// CPanel::CDisableTimerProcessing disableTimerProcessing2(destPanel);
NWindows::CThread thread;
if (thread.Create(CThreadCombine::MyThreadFunction, &combiner) != S_OK)
throw 271824;
progressDialog.Create(title, _window);
}
RefreshTitleAlways();
if (!combiner.Error.IsEmpty())
srcPanel.MessageBoxMyError(combiner.Error);
// disableTimerProcessing1.Restore();
// disableTimerProcessing2.Restore();
// srcPanel.SetFocusToList();
// srcPanel.RefreshListCtrlSaveFocused();
}
void CApp::Split()
{
int srcPanelIndex = GetFocusedPanelIndex();
CPanel &srcPanel = Panels[srcPanelIndex];
if (!srcPanel.IsFSFolder())
{
srcPanel.MessageBox(LangString(IDS_OPERATION_IS_NOT_SUPPORTED, 0x03020208));
return;
}
CRecordVector<UInt32> indices;
srcPanel.GetOperatedItemIndices(indices);
if (indices.IsEmpty())
return;
if (indices.Size() != 1)
{
srcPanel.MessageBox(L"Select one file");
return;
}
int index = indices[0];
if (srcPanel.IsItemFolder(index))
{
srcPanel.MessageBox(L"Select one file");
return;
}
const UString itemName = srcPanel.GetItemName(index);
UString srcPath = srcPanel._currentFolderPrefix + srcPanel.GetItemPrefix(index);
UString path = srcPath;
int destPanelIndex = (NumPanels <= 1) ? srcPanelIndex : (1 - srcPanelIndex);
CPanel &destPanel = Panels[destPanelIndex];
if (NumPanels > 1)
if (destPanel.IsFSFolder())
path = destPanel._currentFolderPrefix;
CSplitDialog splitDialog;
splitDialog.FilePath = srcPanel.GetItemRelPath(index);
splitDialog.Path = path;
if (splitDialog.Create(srcPanel.GetParent()) == IDCANCEL)
return;
NFile::NFind::CFileInfoW fileInfo;
if (!NFile::NFind::FindFile(srcPath + itemName, fileInfo))
{
srcPanel.MessageBoxMyError(L"Can not find file");
return;
}
if (fileInfo.Size <= splitDialog.VolumeSizes.Front())
{
srcPanel.MessageBoxMyError(LangString(IDS_SPLIT_VOL_MUST_BE_SMALLER, 0x03020522));
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, 0x03020521, s),
LangString(IDS_SPLIT_CONFIRM_TITLE, 0x03020520),
MB_YESNOCANCEL | MB_ICONQUESTION | MB_TASKMODAL) != IDYES)
return;
}
path = splitDialog.Path;
NFile::NName::NormalizeDirPathPrefix(path);
if (!NFile::NDirectory::CreateComplexDirectory(path))
{
srcPanel.MessageBoxMyError(MyFormatNew(IDS_CANNOT_CREATE_FOLDER, 0x02000603, path));
return;
}
CThreadSplit spliter;
// spliter.Panel = this;
{
CProgressDialog progressDialog;
spliter.ProgressDialog = &progressDialog;
UString progressWindowTitle = LangString(IDS_APP_TITLE, 0x03000000);
UString title = LangString(IDS_SPLITTING, 0x03020510);
progressDialog.MainWindow = _window;
progressDialog.MainTitle = progressWindowTitle;
progressDialog.MainAddTitle = title + UString(L" ");
progressDialog.ProgressSynch.SetTitleFileName(itemName);
spliter.FilePath = srcPath + itemName;
spliter.VolBasePath = path + itemName;
spliter.VolumeSizes = splitDialog.VolumeSizes;
// if (splitDialog.VolumeSizes.Size() == 0) return;
// CPanel::CDisableTimerProcessing disableTimerProcessing1(srcPanel);
// CPanel::CDisableTimerProcessing disableTimerProcessing2(destPanel);
NWindows::CThread thread;
if (thread.Create(CThreadSplit::MyThreadFunction, &spliter) != S_OK)
throw 271824;
progressDialog.Create(title, _window);
}
RefreshTitleAlways();
if (!spliter.Error.IsEmpty())
srcPanel.MessageBoxMyError(spliter.Error);
// disableTimerProcessing1.Restore();
// disableTimerProcessing2.Restore();
// srcPanel.SetFocusToList();
// srcPanel.RefreshListCtrlSaveFocused();
}
