void CPanel::GetSelectedNames(UStringVector &selectedNames)
{
CRecordVector<UInt32> indices;
GetSelectedItemsIndices(indices);
selectedNames.ClearAndReserve(indices.Size());
FOR_VECTOR (i, indices)
selectedNames.AddInReserved(GetItemRelPath(indices[i]));
/*
for (int i = 0; i < _listView.GetItemCount(); i++)
{
const int kSize = 1024;
WCHAR name[kSize + 1];
LVITEMW item;
item.iItem = i;
item.pszText = name;
item.cchTextMax = kSize;
item.iSubItem = 0;
item.mask = LVIF_TEXT | LVIF_PARAM;
if (!_listView.GetItem(&item))
continue;
int realIndex = GetRealIndex(item);
if (realIndex == kParentIndex)
continue;
if (_selectedStatusVector[realIndex])
selectedNames.Add(item.pszText);
}
*/
selectedNames.Sort();
}
void CContentsView::OnCopy(bool move, bool copyToSame)
{
CContentsView &srcPanel = *this;
CContentsView &destPanel = *this;
CDisableTimerProcessing disableTimerProcessing1(destPanel);
CDisableTimerProcessing disableTimerProcessing2(srcPanel);
if (move)
{
if (!srcPanel.CheckBeforeUpdate(IDS_MOVE))
return;
}
else if (!srcPanel.DoesItSupportOperations())
{
srcPanel.MessageBoxErrorLang(IDS_OPERATION_IS_NOT_SUPPORTED);
return;
}
CRecordVector<UInt32> indices;
UString destPath;
bool useDestPanel = false;
{
if (copyToSame)
{
int focusedItem = srcPanel.GetFocusedItem();
if (focusedItem < 0)
return;
int realIndex = srcPanel.GetRealItemIndex(focusedItem);
if (realIndex == kParentIndex)
return;
indices.Add(realIndex);
destPath = srcPanel.GetItemName(realIndex);
}
else
{
srcPanel.GetOperatedIndicesSmart(indices);
if (indices.Size() == 0)
return;
destPath = destPanel.GetFsPath();
ReducePathToRealFileSystemPath(destPath);
}
}
UStringVector copyFolders;
// ReadCopyHistory(copyFolders);
{
CCopyDialog copyDialog;
copyDialog.Strings = copyFolders;
copyDialog.Value = destPath;
LangString(move ? IDS_MOVE : IDS_COPY, copyDialog.Title);
LangString(move ? IDS_MOVE_TO : IDS_COPY_TO, copyDialog.Static);
copyDialog.Info = srcPanel.GetItemsInfoString(indices);
if (copyDialog.DoModal() != IDOK)
return;
destPath = copyDialog.Value;
}
{
if (destPath.IsEmpty())
{
srcPanel.MessageBoxErrorLang(IDS_OPERATION_IS_NOT_SUPPORTED);
return;
}
UString correctName;
if (!srcPanel.CorrectFsPath(destPath, correctName))
{
srcPanel.MessageBoxError(E_INVALIDARG);
return;
}
if (IsAbsolutePath(destPath))
destPath.Empty();
else
destPath = srcPanel.GetFsPath();
destPath += correctName;
#if defined(_WIN32) && !defined(UNDER_CE)
if (destPath.Len() > 0 && destPath[0] == '\\')
if (destPath.Len() == 1 || destPath[1] != '\\')
{
srcPanel.MessageBoxErrorLang(IDS_OPERATION_IS_NOT_SUPPORTED);
return;
}
#endif
if (CompareFileNames(destPath, destPanel.GetFsPath()) == 0)
{
srcPanel.MessageBoxMyError(L"Can not copy files onto itself");
return;
}
bool destIsFsPath = false;
if (IsAltPathPrefix(us2fs(destPath)))
{
// we allow alt streams dest only to alt stream folder in second panel
srcPanel.MessageBoxErrorLang(IDS_OPERATION_IS_NOT_SUPPORTED);
return;
/*
FString basePath = us2fs(destPath);
basePath.DeleteBack();
if (!DoesFileOrDirExist(basePath))
{
srcPanel.MessageBoxError2Lines(basePath, ERROR_FILE_NOT_FOUND); // GetLastError()
return;
}
destIsFsPath = true;
*/
}
else
{
if (indices.Size() == 1 &&
!destPath.IsEmpty() && destPath.Back() != WCHAR_PATH_SEPARATOR)
{
int pos = destPath.ReverseFind_PathSepar();
if (pos < 0)
{
srcPanel.MessageBoxErrorLang(IDS_OPERATION_IS_NOT_SUPPORTED);
return;
}
{
/*
#ifdef _WIN32
UString name = destPath.Ptr(pos + 1);
if (name.Find(L':') >= 0)
{
srcPanel.MessageBoxErrorLang(IDS_OPERATION_IS_NOT_SUPPORTED);
return;
}
#endif
*/
UString prefix = destPath.Left(pos + 1);
if (!CreateComplexDir(us2fs(prefix)))
{
srcPanel.MessageBoxError2Lines(prefix, GetLastError());
return;
}
}
// bool isFolder = srcPanael.IsItem_Folder(indices[0]);
}
else
{
NName::NormalizeDirPathPrefix(destPath);
if (!CreateComplexDir(us2fs(destPath)))
{
srcPanel.MessageBoxError2Lines(destPath, GetLastError());
return;
}
}
destIsFsPath = true;
}
if (!destIsFsPath)
useDestPanel = true;
// AddUniqueStringToHeadOfList(copyFolders, destPath);
while (copyFolders.Size() > 20)
copyFolders.DeleteBack();
// SaveCopyHistory(copyFolders);
}
bool useSrcPanel = !useDestPanel || !srcPanel.Is_IO_FS_Folder();
bool useTemp = useSrcPanel && useDestPanel;
if (useTemp)
{
srcPanel.MessageBoxErrorLang(IDS_OPERATION_IS_NOT_SUPPORTED);
return;
}
CTempDir tempDirectory;
FString tempDirPrefix;
if (useTemp)
{
tempDirectory.Create(kTempDirPrefix);
tempDirPrefix = tempDirectory.GetPath();
NFile::NName::NormalizeDirPathPrefix(tempDirPrefix);
}
CSelectedState srcSelState;
CSelectedState destSelState;
srcPanel.SaveSelectedState(srcSelState);
destPanel.SaveSelectedState(destSelState);
CDisableNotify disableNotify1(destPanel);
CDisableNotify disableNotify2(srcPanel);
HRESULT result = S_OK;
if (useSrcPanel)
{
CCopyToOptions options;
options.folder = useTemp ? fs2us(tempDirPrefix) : destPath;
options.moveMode = move;
options.includeAltStreams = true;
options.replaceAltStreamChars = false;
options.showErrorMessages = true;
result = srcPanel.CopyTo(options, indices, NULL);
}
if (result == S_OK && useDestPanel)
{
UStringVector filePaths;
UString folderPrefix;
if (useTemp)
folderPrefix = fs2us(tempDirPrefix);
else
folderPrefix = srcPanel.GetFsPath();
filePaths.ClearAndReserve(indices.Size());
FOR_VECTOR(i, indices)
filePaths.AddInReserved(srcPanel.GetItemRelPath2(indices[i]));
result = destPanel.CopyFrom(move, folderPrefix, filePaths, true, 0);
}
if (result != S_OK)
{
// disableNotify1.Restore();
// disableNotify2.Restore();
// For Password:
// srcPanel.SetFocusToList();
// srcPanel.InvalidateList(NULL, true);
if (result != E_ABORT)
srcPanel.MessageBoxError(result, L"Error");
// return;
}
RefreshTitle();
if (copyToSame || move)
{
srcPanel.RefreshListCtrl(srcSelState);
}
if (!copyToSame)
{
destPanel.RefreshListCtrl(destSelState);
srcPanel.KillSelection();
}
disableNotify1.Restore();
disableNotify2.Restore();
srcPanel.SetFocus();
}
void GetUpdatePairInfoList(
const CDirItems &dirItems,
const CObjectVector<CArcItem> &arcItems,
NFileTimeType::EEnum fileTimeType,
CRecordVector<CUpdatePair> &updatePairs)
{
CUIntVector dirIndices, arcIndices;
unsigned numDirItems = dirItems.Items.Size();
unsigned numArcItems = arcItems.Size();
CIntArr duplicatedArcItem(numArcItems);
{
int *vals = &duplicatedArcItem[0];
for (unsigned i = 0; i < numArcItems; i++)
vals[i] = 0;
}
{
arcIndices.ClearAndSetSize(numArcItems);
if (numArcItems != 0)
{
unsigned *vals = &arcIndices[0];
for (unsigned i = 0; i < numArcItems; i++)
vals[i] = i;
}
arcIndices.Sort(CompareArcItems, (void *)&arcItems);
for (unsigned i = 0; i + 1 < numArcItems; i++)
if (CompareArcItemsBase(
arcItems[arcIndices[i]],
arcItems[arcIndices[i + 1]]) == 0)
{
duplicatedArcItem[i] = 1;
duplicatedArcItem[i + 1] = -1;
}
}
UStringVector dirNames;
{
dirNames.ClearAndReserve(numDirItems);
unsigned i;
for (i = 0; i < numDirItems; i++)
dirNames.AddInReserved(dirItems.GetLogPath(i));
SortFileNames(dirNames, dirIndices);
for (i = 0; i + 1 < numDirItems; i++)
{
const UString &s1 = dirNames[dirIndices[i]];
const UString &s2 = dirNames[dirIndices[i + 1]];
if (CompareFileNames(s1, s2) == 0)
ThrowError(k_Duplicate_inDir_Message, s1, s2);
}
}
unsigned dirIndex = 0;
unsigned arcIndex = 0;
int prevHostFile = -1;
const UString *prevHostName = NULL;
while (dirIndex < numDirItems || arcIndex < numArcItems)
{
CUpdatePair pair;
int dirIndex2 = -1;
int arcIndex2 = -1;
const CDirItem *di = NULL;
const CArcItem *ai = NULL;
int compareResult = -1;
const UString *name = NULL;
if (dirIndex < numDirItems)
{
dirIndex2 = dirIndices[dirIndex];
di = &dirItems.Items[dirIndex2];
}
if (arcIndex < numArcItems)
{
arcIndex2 = arcIndices[arcIndex];
ai = &arcItems[arcIndex2];
compareResult = 1;
if (dirIndex < numDirItems)
{
compareResult = CompareFileNames(dirNames[dirIndex2], ai->Name);
if (compareResult == 0)
{
if (di->IsDir() != ai->IsDir)
compareResult = (ai->IsDir ? 1 : -1);
}
}
}
if (compareResult < 0)
{
name = &dirNames[dirIndex2];
pair.State = NUpdateArchive::NPairState::kOnlyOnDisk;
pair.DirIndex = dirIndex2;
dirIndex++;
}
else if (compareResult > 0)
{
name = &ai->Name;
pair.State = ai->Censored ?
NUpdateArchive::NPairState::kOnlyInArchive:
NUpdateArchive::NPairState::kNotMasked;
pair.ArcIndex = arcIndex2;
arcIndex++;
}
else
{
int dupl = duplicatedArcItem[arcIndex];
if (dupl != 0)
ThrowError(k_Duplicate_inArc_Message, ai->Name, arcItems[arcIndices[arcIndex + dupl]].Name);
name = &dirNames[dirIndex2];
if (!ai->Censored)
ThrowError(k_NotCensoredCollision_Message, *name, ai->Name);
pair.DirIndex = dirIndex2;
pair.ArcIndex = arcIndex2;
switch (ai->MTimeDefined ? MyCompareTime(
ai->TimeType != - 1 ? (NFileTimeType::EEnum)ai->TimeType : fileTimeType,
di->MTime, ai->MTime): 0)
{
case -1: pair.State = NUpdateArchive::NPairState::kNewInArchive; break;
case 1: pair.State = NUpdateArchive::NPairState::kOldInArchive; break;
default:
pair.State = (ai->SizeDefined && di->Size == ai->Size) ?
NUpdateArchive::NPairState::kSameFiles :
NUpdateArchive::NPairState::kUnknowNewerFiles;
}
dirIndex++;
arcIndex++;
}
if ((di && di->IsAltStream) ||
(ai && ai->IsAltStream))
{
if (prevHostName)
{
unsigned hostLen = prevHostName->Len();
if (name->Len() > hostLen)
if ((*name)[hostLen] == ':' && CompareFileNames(*prevHostName, name->Left(hostLen)) == 0)
pair.HostIndex = prevHostFile;
}
}
else
{
prevHostFile = updatePairs.Size();
prevHostName = name;
}
updatePairs.Add(pair);
}
updatePairs.ReserveDown();
}