mirror of
https://github.com/Xevion/easy7zip.git
synced 2025-12-08 20:06:58 -06:00
835 lines
21 KiB
C++
Executable File
835 lines
21 KiB
C++
Executable File
// App.cpp
|
|
|
|
#include "StdAfx.h"
|
|
|
|
#include "resource.h"
|
|
|
|
#include "Common/StringConvert.h"
|
|
#include "Windows/FileDir.h"
|
|
#include "Windows/Error.h"
|
|
#include "Windows/COM.h"
|
|
#include "Windows/Thread.h"
|
|
#include "IFolder.h"
|
|
|
|
#include "App.h"
|
|
|
|
#include "Resource/CopyDialog/CopyDialog.h"
|
|
|
|
#include "ExtractCallback.h"
|
|
#include "UpdateCallback100.h"
|
|
#include "ViewSettings.h"
|
|
#include "RegistryUtils.h"
|
|
|
|
using namespace NWindows;
|
|
using namespace NFile;
|
|
using namespace NFind;
|
|
|
|
extern DWORD g_ComCtl32Version;
|
|
extern HINSTANCE g_hInstance;
|
|
|
|
void CPanelCallbackImp::OnTab()
|
|
{
|
|
if (g_App.NumPanels != 1)
|
|
_app->Panels[1 - _index].SetFocusToList();
|
|
}
|
|
|
|
void CPanelCallbackImp::SetFocusToPath(int index)
|
|
{
|
|
int newPanelIndex = index;
|
|
if (g_App.NumPanels == 1)
|
|
newPanelIndex = g_App.LastFocusedPanel;
|
|
_app->Panels[newPanelIndex]._headerComboBox.SetFocus();
|
|
}
|
|
|
|
|
|
void CPanelCallbackImp::OnCopy(UStringVector &externalNames, bool move, bool copyToSame)
|
|
{ _app->OnCopy(externalNames, move, copyToSame, _index); }
|
|
|
|
void CPanelCallbackImp::OnSetSameFolder()
|
|
{ _app->OnSetSameFolder(_index); }
|
|
|
|
void CPanelCallbackImp::OnSetSubFolder()
|
|
{ _app->OnSetSubFolder(_index); }
|
|
|
|
void CPanelCallbackImp::PanelWasFocused()
|
|
{
|
|
_app->LastFocusedPanel = _index;
|
|
}
|
|
|
|
void CApp::SetListSettings()
|
|
{
|
|
bool showDots = ReadShowDots();
|
|
bool showRealFileIcons = ReadShowRealFileIcons();
|
|
|
|
DWORD extendedStyle = LVS_EX_HEADERDRAGDROP;
|
|
if (ReadFullRow())
|
|
extendedStyle |= LVS_EX_FULLROWSELECT;
|
|
if (ReadShowGrid())
|
|
extendedStyle |= LVS_EX_GRIDLINES;
|
|
|
|
/*
|
|
if (ReadSingleClick())
|
|
{
|
|
extendedStyle |= LVS_EX_ONECLICKACTIVATE
|
|
| LVS_EX_TRACKSELECT;
|
|
if (ReadUnderline())
|
|
extendedStyle |= LVS_EX_UNDERLINEHOT;
|
|
}
|
|
*/
|
|
|
|
for (int i = 0; i < kNumPanelsMax; i++)
|
|
{
|
|
Panels[i]._showDots = showDots;
|
|
Panels[i]._showRealFileIcons = showRealFileIcons;
|
|
Panels[i]._exStyle = extendedStyle;
|
|
Panels[i].SetExtendedStyle();
|
|
}
|
|
}
|
|
|
|
void CApp::SetShowSystemMenu()
|
|
{
|
|
ShowSystemMenu = ReadShowSystemMenu();
|
|
}
|
|
|
|
void CApp::CreateOnePanel(int panelIndex, const UString &mainPath)
|
|
{
|
|
if (PanelsCreated[panelIndex])
|
|
return;
|
|
m_PanelCallbackImp[panelIndex].Init(this, panelIndex);
|
|
UString path;
|
|
if (mainPath.IsEmpty())
|
|
{
|
|
CSysString sysPath;
|
|
if (!::ReadPanelPath(panelIndex, sysPath))
|
|
sysPath.Empty();
|
|
path = GetUnicodeString(sysPath);
|
|
}
|
|
else
|
|
path = mainPath;
|
|
int id = 1000 + 100 * panelIndex;
|
|
Panels[panelIndex].Create(_window, _window,
|
|
id, path, &m_PanelCallbackImp[panelIndex], &AppState);
|
|
PanelsCreated[panelIndex] = true;
|
|
}
|
|
|
|
static void CreateToolbar(
|
|
HWND parent,
|
|
NWindows::NControl::CImageList &imageList,
|
|
NWindows::NControl::CToolBar &toolBar,
|
|
bool LargeButtons)
|
|
{
|
|
toolBar.Attach(::CreateWindowEx(0,
|
|
TOOLBARCLASSNAME,
|
|
NULL, 0
|
|
| WS_VISIBLE
|
|
| TBSTYLE_FLAT
|
|
| TBSTYLE_TOOLTIPS
|
|
| WS_CHILD
|
|
| CCS_NOPARENTALIGN
|
|
| CCS_NORESIZE
|
|
| CCS_NODIVIDER
|
|
// | TBSTYLE_AUTOSIZE
|
|
// | CCS_ADJUSTABLE
|
|
,0,0,0,0, parent, NULL, g_hInstance, NULL));
|
|
|
|
// TB_BUTTONSTRUCTSIZE message, which is required for
|
|
// backward compatibility.
|
|
toolBar.ButtonStructSize();
|
|
|
|
imageList.Create(
|
|
LargeButtons ? 48: 24,
|
|
LargeButtons ? 36: 24,
|
|
ILC_MASK, 0, 0);
|
|
toolBar.SetImageList(0, imageList);
|
|
}
|
|
|
|
struct CButtonInfo
|
|
{
|
|
UINT commandID;
|
|
UINT BitmapResID;
|
|
UINT Bitmap2ResID;
|
|
UINT StringResID;
|
|
UINT32 LangID;
|
|
CSysString GetText()const
|
|
{ return LangLoadString(StringResID, LangID); };
|
|
};
|
|
|
|
static CButtonInfo g_StandardButtons[] =
|
|
{
|
|
{ IDM_COPY_TO, IDB_COPY, IDB_COPY2, IDS_BUTTON_COPY, 0x03020420},
|
|
{ IDM_MOVE_TO, IDB_MOVE, IDB_MOVE2, IDS_BUTTON_MOVE, 0x03020421},
|
|
{ IDM_DELETE, IDB_DELETE, IDB_DELETE2, IDS_BUTTON_DELETE, 0x03020422} ,
|
|
{ IDM_FILE_PROPERTIES, IDB_INFO, IDB_INFO2, IDS_BUTTON_INFO, 0x03020423}
|
|
};
|
|
|
|
static CButtonInfo g_ArchiveButtons[] =
|
|
{
|
|
{ kAddCommand, IDB_ADD, IDB_ADD2, IDS_ADD, 0x03020400},
|
|
{ kExtractCommand, IDB_EXTRACT, IDB_EXTRACT2, IDS_EXTRACT, 0x03020401},
|
|
{ kTestCommand , IDB_TEST, IDB_TEST2, IDS_TEST, 0x03020402}
|
|
};
|
|
|
|
bool SetButtonText(UINT32 commandID, CButtonInfo *buttons, int numButtons, CSysString &s)
|
|
{
|
|
for (int i = 0; i < numButtons; i++)
|
|
{
|
|
const CButtonInfo &b = buttons[i];
|
|
if (b.commandID == commandID)
|
|
{
|
|
s = b.GetText();
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void SetButtonText(UINT32 commandID, CSysString &s)
|
|
{
|
|
if (SetButtonText(commandID, g_StandardButtons, sizeof(g_StandardButtons) /
|
|
sizeof(g_StandardButtons[0]), s))
|
|
return;
|
|
SetButtonText(commandID, g_ArchiveButtons, sizeof(g_StandardButtons) /
|
|
sizeof(g_ArchiveButtons[0]), s);
|
|
}
|
|
|
|
static void AddButton(
|
|
NControl::CImageList &imageList,
|
|
NControl::CToolBar &toolBar,
|
|
CButtonInfo &butInfo,
|
|
bool showText,
|
|
bool large)
|
|
{
|
|
TBBUTTON but;
|
|
but.iBitmap = 0;
|
|
but.idCommand = butInfo.commandID;
|
|
but.fsState = TBSTATE_ENABLED;
|
|
but.fsStyle = BTNS_BUTTON
|
|
// | BTNS_AUTOSIZE
|
|
;
|
|
but.dwData = 0;
|
|
|
|
CSysString s = butInfo.GetText();
|
|
but.iString = 0;
|
|
if (showText)
|
|
but.iString = (INT_PTR )(LPCTSTR)s;
|
|
|
|
but.iBitmap = imageList.GetImageCount();
|
|
HBITMAP b = ::LoadBitmap(g_hInstance,
|
|
large ?
|
|
(LPCTSTR)butInfo.BitmapResID:
|
|
(LPCTSTR)butInfo.Bitmap2ResID);
|
|
if (b != 0)
|
|
{
|
|
imageList.AddMasked(b, RGB(255, 0, 255));
|
|
::DeleteObject(b);
|
|
}
|
|
toolBar.AddButton(1, &but);
|
|
}
|
|
|
|
static void AddBand(NControl::CReBar &reBar, NControl::CToolBar &toolBar)
|
|
{
|
|
SIZE size;
|
|
toolBar.GetMaxSize(&size);
|
|
|
|
RECT rect;
|
|
toolBar.GetWindowRect(&rect);
|
|
|
|
REBARBANDINFO rbBand;
|
|
rbBand.cbSize = sizeof(REBARBANDINFO); // Required
|
|
rbBand.fMask = RBBIM_STYLE
|
|
| RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_SIZE;
|
|
rbBand.fStyle = RBBS_CHILDEDGE; // RBBS_NOGRIPPER;
|
|
rbBand.cxMinChild = size.cx; // rect.right - rect.left;
|
|
rbBand.cyMinChild = size.cy; // rect.bottom - rect.top;
|
|
rbBand.cyChild = rbBand.cyMinChild;
|
|
rbBand.cx = rbBand.cxMinChild;
|
|
rbBand.cxIdeal = rbBand.cxMinChild;
|
|
rbBand.hwndChild = toolBar;
|
|
reBar.InsertBand(-1, &rbBand);
|
|
}
|
|
|
|
void CApp::ReloadToolbars()
|
|
{
|
|
if (!_rebar)
|
|
return;
|
|
HWND parent = _rebar;
|
|
|
|
while(_rebar.GetBandCount() > 0)
|
|
_rebar.DeleteBand(0);
|
|
|
|
_archiveToolBar.Destroy();
|
|
_archiveButtonsImageList.Destroy();
|
|
|
|
_standardButtonsImageList.Destroy();
|
|
_standardToolBar.Destroy();
|
|
|
|
if (ShowArchiveToolbar)
|
|
{
|
|
CreateToolbar(parent, _archiveButtonsImageList, _archiveToolBar, LargeButtons);
|
|
for (int i = 0; i < sizeof(g_ArchiveButtons) / sizeof(g_ArchiveButtons[0]); i++)
|
|
AddButton(_archiveButtonsImageList, _archiveToolBar, g_ArchiveButtons[i],
|
|
ShowButtonsLables, LargeButtons);
|
|
AddBand(_rebar, _archiveToolBar);
|
|
}
|
|
|
|
if (ShowStandardToolbar)
|
|
{
|
|
CreateToolbar(parent, _standardButtonsImageList, _standardToolBar, LargeButtons);
|
|
for (int i = 0; i < sizeof(g_StandardButtons) / sizeof(g_StandardButtons[0]); i++)
|
|
AddButton(_standardButtonsImageList, _standardToolBar, g_StandardButtons[i],
|
|
ShowButtonsLables, LargeButtons);
|
|
AddBand(_rebar, _standardToolBar);
|
|
}
|
|
}
|
|
|
|
void CApp::ReloadRebar(HWND hwnd)
|
|
{
|
|
_rebar.Destroy();
|
|
if (!ShowArchiveToolbar && !ShowStandardToolbar)
|
|
return;
|
|
if (g_ComCtl32Version >= MAKELONG(71, 4))
|
|
{
|
|
INITCOMMONCONTROLSEX icex;
|
|
icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
|
|
icex.dwICC = ICC_COOL_CLASSES | ICC_BAR_CLASSES;
|
|
InitCommonControlsEx(&icex);
|
|
|
|
_rebar.Attach(::CreateWindowEx(WS_EX_TOOLWINDOW,
|
|
REBARCLASSNAME,
|
|
NULL,
|
|
WS_VISIBLE
|
|
| WS_BORDER
|
|
| WS_CHILD
|
|
| WS_CLIPCHILDREN
|
|
| WS_CLIPSIBLINGS
|
|
// | CCS_NODIVIDER
|
|
// | CCS_NOPARENTALIGN // it's bead for moveing of two bands
|
|
// | CCS_TOP
|
|
| RBS_VARHEIGHT
|
|
| RBS_BANDBORDERS
|
|
// | RBS_AUTOSIZE
|
|
,0,0,0,0, hwnd, NULL, g_hInstance, NULL));
|
|
}
|
|
if (_rebar == 0)
|
|
return;
|
|
REBARINFO rbi;
|
|
rbi.cbSize = sizeof(REBARINFO); // Required when using this struct.
|
|
rbi.fMask = 0;
|
|
rbi.himl = (HIMAGELIST)NULL;
|
|
_rebar.SetBarInfo(&rbi);
|
|
ReloadToolbars();
|
|
}
|
|
|
|
void CApp::Create(HWND hwnd, const UString &mainPath, int xSizes[2])
|
|
{
|
|
ReadToolbar();
|
|
ReloadRebar(hwnd);
|
|
|
|
for (int i = 0; i < kNumPanelsMax; i++)
|
|
PanelsCreated[i] = false;
|
|
|
|
_window.Attach(hwnd);
|
|
AppState.Read();
|
|
SetListSettings();
|
|
SetShowSystemMenu();
|
|
UString mainPathSpec = mainPath;
|
|
if (LastFocusedPanel >= kNumPanelsMax)
|
|
LastFocusedPanel = 0;
|
|
|
|
CListMode listMode;
|
|
ReadListMode(listMode);
|
|
for (i = 0; i < kNumPanelsMax; i++)
|
|
{
|
|
Panels[i]._ListViewMode = listMode.Panels[i];
|
|
Panels[i]._xSize = xSizes[i];
|
|
}
|
|
for (i = 0; i < kNumPanelsMax; i++)
|
|
if (NumPanels > 1 || i == LastFocusedPanel)
|
|
{
|
|
if (NumPanels == 1)
|
|
Panels[i]._xSize = xSizes[0] + xSizes[1];
|
|
CreateOnePanel(i, (i == LastFocusedPanel) ? mainPath : L"");
|
|
}
|
|
Panels[LastFocusedPanel].SetFocusToList();
|
|
}
|
|
|
|
extern void MoveSubWindows(HWND hWnd);
|
|
|
|
void CApp::SwitchOnOffOnePanel()
|
|
{
|
|
if (NumPanels == 1)
|
|
{
|
|
NumPanels++;
|
|
CreateOnePanel(1 - LastFocusedPanel, UString());
|
|
Panels[1 - LastFocusedPanel].Enable(true);
|
|
Panels[1 - LastFocusedPanel].Show(SW_SHOWNORMAL);
|
|
}
|
|
else
|
|
{
|
|
NumPanels--;
|
|
Panels[1 - LastFocusedPanel].Enable(false);
|
|
Panels[1 - LastFocusedPanel].Show(SW_HIDE);
|
|
}
|
|
MoveSubWindows(_window);
|
|
}
|
|
|
|
void CApp::Save()
|
|
{
|
|
AppState.Save();
|
|
CListMode listMode;
|
|
for (int i = 0; i < kNumPanelsMax; i++)
|
|
{
|
|
const CPanel &panel = Panels[i];
|
|
UString path;
|
|
if (panel._parentFolders.IsEmpty())
|
|
path = panel._currentFolderPrefix;
|
|
else
|
|
path = GetFolderPath(panel._parentFolders[0].ParentFolder);
|
|
SavePanelPath(i, GetSystemString(path));
|
|
listMode.Panels[i] = panel.GetListViewMode();
|
|
}
|
|
SaveListMode(listMode);
|
|
}
|
|
|
|
void CApp::Release()
|
|
{
|
|
// It's for unloading COM dll's: don't change it.
|
|
for (int i = 0; i < kNumPanelsMax; i++)
|
|
Panels[i].Release();
|
|
}
|
|
|
|
class CWindowDisable
|
|
{
|
|
bool _wasEnabled;
|
|
CWindow _window;
|
|
public:
|
|
CWindowDisable(HWND window): _window(window)
|
|
{
|
|
_wasEnabled = _window.IsEnabled();
|
|
if (_wasEnabled)
|
|
_window.Enable(false);
|
|
}
|
|
~CWindowDisable()
|
|
{
|
|
if (_wasEnabled)
|
|
_window.Enable(true);
|
|
}
|
|
};
|
|
|
|
struct CThreadExtract
|
|
{
|
|
bool Move;
|
|
CMyComPtr<IFolderOperations> FolderOperations;
|
|
CRecordVector<UINT32> Indices;
|
|
UString DestPath;
|
|
CExtractCallbackImp *ExtractCallbackSpec;
|
|
CMyComPtr<IFolderOperationsExtractCallback> ExtractCallback;
|
|
HRESULT Result;
|
|
|
|
DWORD Extract()
|
|
{
|
|
NCOM::CComInitializer comInitializer;
|
|
ExtractCallbackSpec->ProgressDialog.WaitCreating();
|
|
if (Move)
|
|
{
|
|
Result = FolderOperations->MoveTo(
|
|
&Indices.Front(), Indices.Size(),
|
|
DestPath, ExtractCallback);
|
|
// ExtractCallbackSpec->DestroyWindows();
|
|
}
|
|
else
|
|
{
|
|
Result = FolderOperations->CopyTo(
|
|
&Indices.Front(), Indices.Size(),
|
|
DestPath, ExtractCallback);
|
|
// ExtractCallbackSpec->DestroyWindows();
|
|
}
|
|
ExtractCallbackSpec->ProgressDialog.MyClose();
|
|
return 0;
|
|
}
|
|
|
|
static DWORD WINAPI MyThreadFunction(void *param)
|
|
{
|
|
return ((CThreadExtract *)param)->Extract();
|
|
}
|
|
};
|
|
|
|
struct CThreadUpdate
|
|
{
|
|
bool Move;
|
|
CMyComPtr<IFolderOperations> FolderOperations;
|
|
UString SrcFolderPrefix;
|
|
UStringVector FileNames;
|
|
CRecordVector<const wchar_t *> FileNamePointers;
|
|
CMyComPtr<IFolderArchiveUpdateCallback> UpdateCallback;
|
|
CUpdateCallback100Imp *UpdateCallbackSpec;
|
|
HRESULT Result;
|
|
|
|
DWORD Process()
|
|
{
|
|
NCOM::CComInitializer comInitializer;
|
|
UpdateCallbackSpec->ProgressDialog.WaitCreating();
|
|
if (Move)
|
|
{
|
|
{
|
|
throw 1;
|
|
// srcPanel.MessageBoxMyError(L"Move is not supported");
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Result = FolderOperations->CopyFrom(
|
|
SrcFolderPrefix,
|
|
&FileNamePointers.Front(),
|
|
FileNamePointers.Size(),
|
|
UpdateCallback);
|
|
}
|
|
UpdateCallbackSpec->ProgressDialog.MyClose();
|
|
return 0;
|
|
}
|
|
|
|
static DWORD WINAPI MyThreadFunction(void *param)
|
|
{
|
|
return ((CThreadUpdate *)param)->Process();
|
|
}
|
|
};
|
|
|
|
|
|
|
|
void CApp::OnCopy(UStringVector &externalNames, bool move, bool copyToSame, int srcPanelIndex)
|
|
{
|
|
bool external = (externalNames.Size() > 0);
|
|
if (external)
|
|
copyToSame = true;
|
|
|
|
int destPanelIndex = (NumPanels <= 1) ? srcPanelIndex : (1 - srcPanelIndex);
|
|
CPanel &srcPanel = Panels[srcPanelIndex];
|
|
CPanel &destPanel = Panels[destPanelIndex];
|
|
|
|
CPanel::CDisableTimerProcessing disableTimerProcessing1(destPanel);
|
|
CPanel::CDisableTimerProcessing disableTimerProcessing2(srcPanel);
|
|
|
|
bool useSrcPanel = true;
|
|
if (!external)
|
|
if (NumPanels != 1)
|
|
{
|
|
if (!srcPanel.IsFSFolder() && !destPanel.IsFSFolder())
|
|
{
|
|
srcPanel.MessageBox(LangLoadStringW(IDS_CANNOT_COPY, 0x03020207));
|
|
return;
|
|
}
|
|
useSrcPanel = copyToSame || destPanel.IsFSFolder();
|
|
if (move && !useSrcPanel)
|
|
{
|
|
srcPanel.MessageBoxMyError(L"Move is not supported");
|
|
return;
|
|
}
|
|
}
|
|
|
|
CPanel &panel = useSrcPanel ? srcPanel : destPanel;
|
|
|
|
CMyComPtr<IFolderOperations> folderOperations;
|
|
|
|
// if (move)
|
|
if (panel._folder.QueryInterface(IID_IFolderOperations,
|
|
&folderOperations) != S_OK)
|
|
{
|
|
panel.MessageBox(LangLoadStringW(IDS_OPERATION_IS_NOT_SUPPORTED, 0x03020208));
|
|
return;
|
|
}
|
|
|
|
CRecordVector<UINT32> indices;
|
|
UString destPath;
|
|
|
|
if (external)
|
|
{
|
|
UString message = L"Are you sure you want to copy files to archive \'";
|
|
message += srcPanel._currentFolderPrefix;
|
|
message += L"\'?";
|
|
int res = MessageBoxW(_window, message, L"Confirm File Copy",
|
|
MB_YESNOCANCEL | MB_ICONQUESTION | MB_TASKMODAL);
|
|
if (res != IDYES)
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
CCopyDialog copyDialog;
|
|
|
|
UStringVector copyFolders;
|
|
ReadCopyHistory(copyFolders);
|
|
|
|
int i;
|
|
for (i = 0; i < copyFolders.Size(); i++)
|
|
copyDialog.Strings.Add(GetSystemString(copyFolders[i]));
|
|
|
|
if (copyToSame)
|
|
{
|
|
int focusedItem = srcPanel._listView.GetFocusedItem();
|
|
if (focusedItem < 0)
|
|
return;
|
|
int realIndex = srcPanel.GetRealItemIndex(focusedItem);
|
|
if (realIndex == -1)
|
|
return;
|
|
indices.Add(realIndex);
|
|
copyDialog.Value = srcPanel.GetItemName(realIndex);
|
|
}
|
|
else
|
|
{
|
|
srcPanel.GetOperatedItemIndices(indices);
|
|
if (indices.Size() == 0)
|
|
return;
|
|
UString destPath = destPanel._currentFolderPrefix;
|
|
if (NumPanels == 1)
|
|
{
|
|
while(!destPath.IsEmpty())
|
|
{
|
|
CFileInfoW fileInfo;
|
|
if (FindFile(destPath, fileInfo))
|
|
{
|
|
if (fileInfo.IsDirectory())
|
|
{
|
|
destPath += L'\\';
|
|
break;
|
|
}
|
|
}
|
|
int pos = destPath.ReverseFind('\\');
|
|
if (pos < 0)
|
|
destPath.Empty();
|
|
else
|
|
{
|
|
destPath = destPath.Left(pos + 1);
|
|
if (destPath.Length() == 3 && destPath[1] == L':')
|
|
break;
|
|
destPath = destPath.Left(pos);
|
|
}
|
|
}
|
|
}
|
|
copyDialog.Value = destPath;
|
|
}
|
|
copyDialog.Title = move ?
|
|
LangLoadStringW(IDS_MOVE, 0x03020202):
|
|
LangLoadStringW(IDS_COPY, 0x03020201);
|
|
copyDialog.Static = move ?
|
|
LangLoadStringW(IDS_MOVE_TO, 0x03020204):
|
|
LangLoadStringW(IDS_COPY_TO, 0x03020203);
|
|
if (copyDialog.Create(srcPanel.GetParent()) == IDCANCEL)
|
|
return;
|
|
|
|
AddUniqueStringToHeadOfList(copyFolders, GetUnicodeString(
|
|
copyDialog.Value));
|
|
while (copyFolders.Size() > 20)
|
|
copyFolders.DeleteBack();
|
|
|
|
SaveCopyHistory(copyFolders);
|
|
|
|
/// ?????
|
|
SetCurrentDirectory(GetSystemString(srcPanel._currentFolderPrefix));
|
|
|
|
if (!NDirectory::MyGetFullPathName(copyDialog.Value, destPath))
|
|
{
|
|
srcPanel.MessageBoxLastError();
|
|
return;
|
|
}
|
|
|
|
if (destPath.Length() > 0 && destPath.ReverseFind('\\') == destPath.Length() - 1)
|
|
NDirectory::CreateComplexDirectory(destPath);
|
|
}
|
|
|
|
UString title = move ?
|
|
LangLoadStringW(IDS_MOVING, 0x03020206):
|
|
LangLoadStringW(IDS_COPYING, 0x03020205);
|
|
UString progressWindowTitle = LangLoadStringW(IDS_APP_TITLE, 0x03000000);
|
|
|
|
CSelectedState srcSelState;
|
|
CSelectedState destSelState;
|
|
if (copyToSame || move)
|
|
srcPanel.SaveSelectedState(srcSelState);
|
|
if (!copyToSame)
|
|
destPanel.SaveSelectedState(destSelState);
|
|
|
|
HRESULT result;
|
|
if (useSrcPanel && !external)
|
|
{
|
|
CThreadExtract extracter;
|
|
extracter.ExtractCallbackSpec = new CExtractCallbackImp;
|
|
extracter.ExtractCallback = extracter.ExtractCallbackSpec;
|
|
extracter.ExtractCallbackSpec->ParentWindow = _window;
|
|
|
|
extracter.ExtractCallbackSpec->ProgressDialog.MainWindow = _window;
|
|
extracter.ExtractCallbackSpec->ProgressDialog.MainTitle = progressWindowTitle;
|
|
extracter.ExtractCallbackSpec->ProgressDialog.MainAddTitle = title + L" ";
|
|
extracter.ExtractCallbackSpec->OverwriteMode = NExtract::NOverwriteMode::kAskBefore;
|
|
|
|
extracter.ExtractCallbackSpec->Init();
|
|
extracter.Move = move;
|
|
extracter.FolderOperations = folderOperations;
|
|
extracter.Indices = indices;;
|
|
extracter.DestPath = GetUnicodeString(destPath);
|
|
CThread thread;
|
|
if (!thread.Create(CThreadExtract::MyThreadFunction, &extracter))
|
|
throw 271824;
|
|
extracter.ExtractCallbackSpec->StartProgressDialog(title);
|
|
result = extracter.Result;
|
|
}
|
|
else
|
|
{
|
|
CThreadUpdate updater;
|
|
updater.UpdateCallbackSpec = new CUpdateCallback100Imp;
|
|
updater.UpdateCallback = updater.UpdateCallbackSpec;
|
|
|
|
updater.UpdateCallbackSpec->ProgressDialog.MainWindow = _window;
|
|
updater.UpdateCallbackSpec->ProgressDialog.MainTitle = progressWindowTitle;
|
|
updater.UpdateCallbackSpec->ProgressDialog.MainAddTitle = title + UString(L" ");
|
|
|
|
updater.UpdateCallbackSpec->Init(_window, false, L"");
|
|
updater.Move = move;
|
|
updater.FolderOperations = folderOperations;
|
|
if (external)
|
|
{
|
|
updater.FileNames.Reserve(externalNames.Size());
|
|
for(int i = 0; i < externalNames.Size(); i++)
|
|
updater.FileNames.Add(externalNames[i]);
|
|
}
|
|
else
|
|
{
|
|
updater.SrcFolderPrefix = srcPanel._currentFolderPrefix;
|
|
updater.FileNames.Reserve(indices.Size());
|
|
for(int i = 0; i < indices.Size(); i++)
|
|
updater.FileNames.Add(srcPanel.GetItemName(indices[i]));
|
|
}
|
|
updater.FileNamePointers.Reserve(updater.FileNames.Size());
|
|
int i;
|
|
for(i = 0; i < updater.FileNames.Size(); i++)
|
|
updater.FileNamePointers.Add(updater.FileNames[i]);
|
|
CThread thread;
|
|
if (!thread.Create(CThreadUpdate::MyThreadFunction, &updater))
|
|
throw 271824;
|
|
updater.UpdateCallbackSpec->StartProgressDialog(title);
|
|
result = updater.Result;
|
|
}
|
|
|
|
/*
|
|
if (useSrcPanel)
|
|
extractCallbackSpec->DestroyWindows();
|
|
*/
|
|
|
|
if (result != S_OK)
|
|
{
|
|
disableTimerProcessing1.Restore();
|
|
disableTimerProcessing2.Restore();
|
|
// For Password:
|
|
srcPanel.SetFocusToList();
|
|
if (result != E_ABORT)
|
|
srcPanel.MessageBoxError(result, L"Error");
|
|
return;
|
|
}
|
|
if (copyToSame || move)
|
|
{
|
|
srcPanel.RefreshListCtrl(srcSelState);
|
|
}
|
|
if (!copyToSame)
|
|
{
|
|
destPanel.RefreshListCtrl(destSelState);
|
|
srcPanel.KillSelection();
|
|
}
|
|
disableTimerProcessing1.Restore();
|
|
disableTimerProcessing2.Restore();
|
|
srcPanel.SetFocusToList();
|
|
}
|
|
|
|
|
|
void CApp::OnSetSameFolder(int srcPanelIndex)
|
|
{
|
|
if (NumPanels <= 1)
|
|
return;
|
|
const CPanel &srcPanel = Panels[srcPanelIndex];
|
|
CPanel &destPanel = Panels[1 - srcPanelIndex];
|
|
destPanel.BindToPathAndRefresh(srcPanel._currentFolderPrefix);
|
|
}
|
|
|
|
void CApp::OnSetSubFolder(int srcPanelIndex)
|
|
{
|
|
if (NumPanels <= 1)
|
|
return;
|
|
const CPanel &srcPanel = Panels[srcPanelIndex];
|
|
CPanel &destPanel = Panels[1 - srcPanelIndex];
|
|
|
|
int focusedItem = srcPanel._listView.GetFocusedItem();
|
|
if (focusedItem < 0)
|
|
return;
|
|
int realIndex = srcPanel.GetRealItemIndex(focusedItem);
|
|
if (!srcPanel.IsItemFolder(realIndex))
|
|
return;
|
|
|
|
|
|
/*
|
|
UString string = srcPanel._currentFolderPrefix +
|
|
srcPanel.GetItemName(realIndex) + L'\\';
|
|
destPanel.BindToFolder(string);
|
|
*/
|
|
CMyComPtr<IFolderFolder> newFolder;
|
|
if (realIndex == -1)
|
|
{
|
|
if (srcPanel._folder->BindToParentFolder(&newFolder) != S_OK)
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if (srcPanel._folder->BindToFolder(realIndex, &newFolder) != S_OK)
|
|
return;
|
|
}
|
|
destPanel._folder = newFolder;
|
|
destPanel.RefreshListCtrl();
|
|
}
|
|
|
|
/*
|
|
int CApp::GetFocusedPanelIndex() const
|
|
{
|
|
return LastFocusedPanel;
|
|
HWND hwnd = ::GetFocus();
|
|
while(true)
|
|
{
|
|
if (hwnd == 0)
|
|
return 0;
|
|
for (int i = 0; i < kNumPanelsMax; i++)
|
|
{
|
|
if (PanelsCreated[i] &&
|
|
((HWND)Panels[i] == hwnd || Panels[i]._listView == hwnd))
|
|
return i;
|
|
}
|
|
hwnd = GetParent(hwnd);
|
|
}
|
|
}
|
|
*/
|
|
|
|
static CSysString g_ToolTipBuffer;
|
|
|
|
void CApp::OnNotify(int ctrlID, LPNMHDR pnmh)
|
|
{
|
|
if (pnmh->hwndFrom == _rebar)
|
|
{
|
|
switch(pnmh->code)
|
|
{
|
|
case RBN_HEIGHTCHANGE:
|
|
{
|
|
MoveSubWindows(g_HWND);
|
|
return;
|
|
}
|
|
}
|
|
return ;
|
|
}
|
|
else
|
|
{
|
|
if (pnmh->code == TTN_GETDISPINFO)
|
|
{
|
|
LPNMTTDISPINFO info = (LPNMTTDISPINFO)pnmh;
|
|
info->hinst = 0;
|
|
g_ToolTipBuffer.Empty();
|
|
SetButtonText(info->hdr.idFrom, g_ToolTipBuffer);
|
|
info->lpszText = (LPTSTR)(LPCTSTR)g_ToolTipBuffer;
|
|
return;
|
|
}
|
|
}
|
|
}
|