2349 lines
97 KiB
C++
2349 lines
97 KiB
C++
#include <windows.h>
|
|
#include <commctrl.h>
|
|
#include <windowsx.h>
|
|
#include <shellapi.h>
|
|
#include <shlobj.h>
|
|
#include <commdlg.h>
|
|
#include <algorithm>
|
|
#include <filesystem>
|
|
#include <iomanip>
|
|
#include <map>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <objbase.h>
|
|
|
|
namespace
|
|
{
|
|
namespace fs = std::filesystem;
|
|
|
|
std::wstring formatSize(uint64_t bytes,size_t columns=0)
|
|
{
|
|
constexpr const wchar_t *units[]{L"B",L"KiB",L"MiB",L"GiB",L"TiB",L"PiB",L"EiB"};
|
|
constexpr const wchar_t *compact[]{L"",L"K",L"M",L"G",L"T",L"P",L"E"};
|
|
if(columns)
|
|
{
|
|
for(size_t unit=0;;++unit,bytes/=1024)
|
|
{
|
|
auto label=std::to_wstring(bytes)+compact[unit];
|
|
if(label.size()<=columns || unit==std::size(compact)-1) return label;
|
|
}
|
|
}
|
|
size_t unit=0;
|
|
double value=static_cast<double>(bytes);
|
|
while(value>=1024 && unit+1<std::size(units))
|
|
{
|
|
value/=1024;
|
|
++unit;
|
|
}
|
|
if(!unit) return std::to_wstring(bytes)+L" B";
|
|
std::wostringstream label;
|
|
label<<std::fixed<<std::setprecision(2)<<value<<L' '<<units[unit];
|
|
return label.str();
|
|
}
|
|
constexpr wchar_t folderPipePrefix[]=L"\\\\.\\pipe\\KSwitcher.Files.Folder.";
|
|
struct Handle
|
|
{
|
|
HANDLE value;
|
|
~Handle(){if(value && value!=INVALID_HANDLE_VALUE) CloseHandle(value);}
|
|
};
|
|
struct FolderEntryMetadata
|
|
{
|
|
DWORD attributes;
|
|
ULONGLONG size;
|
|
};
|
|
|
|
DWORD enableBackupPrivilege()
|
|
{
|
|
Handle token{};
|
|
if(!OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY,&token.value))
|
|
return GetLastError();
|
|
|
|
TOKEN_PRIVILEGES privileges{};
|
|
privileges.PrivilegeCount=1;
|
|
privileges.Privileges[0].Attributes=SE_PRIVILEGE_ENABLED;
|
|
if(!LookupPrivilegeValueW(nullptr,SE_BACKUP_NAME,&privileges.Privileges[0].Luid))
|
|
return GetLastError();
|
|
|
|
AdjustTokenPrivileges(token.value,FALSE,&privileges,0,nullptr,nullptr);
|
|
return GetLastError();
|
|
}
|
|
|
|
DWORD listElevatedFolder(const fs::path &directory, const std::wstring &pipeName)
|
|
{
|
|
if(!IsUserAnAdmin() || !directory.is_absolute() || !pipeName.starts_with(folderPipePrefix))
|
|
return ERROR_ACCESS_DENIED;
|
|
Handle pipe{CreateFileW(pipeName.c_str(),GENERIC_READ|GENERIC_WRITE,0,nullptr,OPEN_EXISTING,
|
|
SECURITY_SQOS_PRESENT|SECURITY_IDENTIFICATION,nullptr)};
|
|
if(pipe.value==INVALID_HANDLE_VALUE) return GetLastError();
|
|
// Keep the connection open until the parent verifies the helper's process ID.
|
|
char ready{};
|
|
DWORD received{};
|
|
if(!ReadFile(pipe.value,&ready,sizeof(ready),&received,nullptr)) return GetLastError();
|
|
if(received!=sizeof(ready) || ready!=1) return ERROR_INVALID_DATA;
|
|
if(const auto error=enableBackupPrivilege();error!=ERROR_SUCCESS)
|
|
return error;
|
|
Handle folder{CreateFileW(directory.c_str(),FILE_LIST_DIRECTORY,
|
|
FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,nullptr,OPEN_EXISTING,
|
|
FILE_FLAG_BACKUP_SEMANTICS,nullptr)};
|
|
if(folder.value==INVALID_HANDLE_VALUE) return GetLastError();
|
|
|
|
alignas(FILE_ID_BOTH_DIR_INFO) unsigned char buffer[16384];
|
|
while(GetFileInformationByHandleEx(folder.value,FileIdBothDirectoryInfo,buffer,sizeof(buffer)))
|
|
{
|
|
auto entry=reinterpret_cast<const FILE_ID_BOTH_DIR_INFO*>(buffer);
|
|
for(;;)
|
|
{
|
|
std::wstring_view name(entry->FileName,entry->FileNameLength/sizeof(wchar_t));
|
|
if(name!=L"." && name!=L"..")
|
|
{
|
|
const FolderEntryMetadata metadata{entry->FileAttributes,
|
|
static_cast<ULONGLONG>(entry->EndOfFile.QuadPart)};
|
|
std::wstring row(sizeof(metadata)/sizeof(wchar_t),L'\0');
|
|
memcpy(row.data(),&metadata,sizeof(metadata));
|
|
row.append(name);
|
|
DWORD written{};
|
|
if(!WriteFile(pipe.value,row.data(),static_cast<DWORD>(row.size()*sizeof(wchar_t)),&written,nullptr))
|
|
return GetLastError();
|
|
}
|
|
if(!entry->NextEntryOffset) break;
|
|
entry=reinterpret_cast<const FILE_ID_BOTH_DIR_INFO*>(
|
|
reinterpret_cast<const unsigned char*>(entry)+entry->NextEntryOffset);
|
|
}
|
|
}
|
|
const auto error=GetLastError();
|
|
return error==ERROR_NO_MORE_FILES?ERROR_SUCCESS:error;
|
|
}
|
|
|
|
DWORD requestElevatedFolder(HWND owner,const fs::path &directory,
|
|
std::vector<fs::path> &folders,std::vector<fs::path> &files,
|
|
std::map<fs::path,FolderEntryMetadata> &metadata)
|
|
{
|
|
GUID id{};
|
|
wchar_t token[40]{}, executable[32768]{};
|
|
auto length=GetModuleFileNameW(nullptr,executable,static_cast<DWORD>(std::size(executable)));
|
|
if(!length || length>=std::size(executable) || FAILED(CoCreateGuid(&id)) ||
|
|
!StringFromGUID2(id,token,static_cast<int>(std::size(token)))) return ERROR_GEN_FAILURE;
|
|
auto name=std::wstring(folderPipePrefix)+token;
|
|
Handle pipe{CreateNamedPipeW(name.c_str(),PIPE_ACCESS_DUPLEX|FILE_FLAG_FIRST_PIPE_INSTANCE,
|
|
PIPE_TYPE_MESSAGE|PIPE_READMODE_MESSAGE|PIPE_NOWAIT|PIPE_REJECT_REMOTE_CLIENTS,1,0,4096,0,nullptr)};
|
|
if(pipe.value==INVALID_HANDLE_VALUE) return GetLastError();
|
|
auto parameters=L"--list-folder \""+(directory/L".").wstring()+L"\" \""+name+L"\"";
|
|
SHELLEXECUTEINFOW launch{};
|
|
launch.cbSize=sizeof(launch);
|
|
launch.fMask=SEE_MASK_NOCLOSEPROCESS|SEE_MASK_NOASYNC;
|
|
launch.hwnd=owner;
|
|
launch.lpVerb=L"runas";
|
|
launch.lpFile=executable;
|
|
launch.lpParameters=parameters.c_str();
|
|
launch.nShow=SW_HIDE;
|
|
if(!ShellExecuteExW(&launch)) return GetLastError();
|
|
Handle process{launch.hProcess};
|
|
bool connected=false;
|
|
bool finished=false;
|
|
auto deadline=GetTickCount64()+10000;
|
|
while(GetTickCount64()<deadline)
|
|
{
|
|
if(!connected)
|
|
{
|
|
connected=ConnectNamedPipe(pipe.value,nullptr) || GetLastError()==ERROR_PIPE_CONNECTED;
|
|
if(connected)
|
|
{
|
|
ULONG client{};
|
|
if(!GetNamedPipeClientProcessId(pipe.value,&client) || client!=GetProcessId(process.value))
|
|
return ERROR_ACCESS_DENIED;
|
|
const char ready=1;
|
|
DWORD written{};
|
|
if(!WriteFile(pipe.value,&ready,sizeof(ready),&written,nullptr)) return GetLastError();
|
|
if(written!=sizeof(ready)) return ERROR_WRITE_FAULT;
|
|
}
|
|
}
|
|
if(connected)
|
|
{
|
|
wchar_t row[512]{};
|
|
DWORD bytes{};
|
|
if(ReadFile(pipe.value,row,sizeof(row),&bytes,nullptr))
|
|
{
|
|
FolderEntryMetadata entry{};
|
|
if(bytes<=sizeof(entry) || bytes%sizeof(wchar_t)) return ERROR_INVALID_DATA;
|
|
memcpy(&entry,row,sizeof(entry));
|
|
const std::wstring_view name(row+sizeof(entry)/sizeof(wchar_t),(bytes-sizeof(entry))/sizeof(wchar_t));
|
|
if(name.find(L'\0')!=name.npos) return ERROR_INVALID_DATA;
|
|
const fs::path child(name);
|
|
if(child!=child.filename() || child==L"." || child==L"..") return ERROR_INVALID_DATA;
|
|
const auto path=directory/child;
|
|
(entry.attributes&FILE_ATTRIBUTE_DIRECTORY?folders:files).push_back(path);
|
|
metadata.emplace(path,entry);
|
|
continue;
|
|
}
|
|
}
|
|
if(finished)
|
|
{
|
|
DWORD result{};
|
|
if(!GetExitCodeProcess(process.value,&result)) return GetLastError();
|
|
return !connected && result==ERROR_SUCCESS ? ERROR_PIPE_NOT_CONNECTED : result;
|
|
}
|
|
finished=WaitForSingleObject(process.value,20)==WAIT_OBJECT_0;
|
|
}
|
|
return ERROR_TIMEOUT;
|
|
}
|
|
struct Panel
|
|
{
|
|
HWND path{}, list{}, heading{};
|
|
fs::path directory;
|
|
std::vector<fs::path> rows;
|
|
std::vector<std::wstring> sizes;
|
|
std::vector<bool> dimmed;
|
|
std::vector<bool> marked;
|
|
bool wide{};
|
|
};
|
|
Panel panels[2];
|
|
HWND status{}, commands[5]{};
|
|
int active{}, split{};
|
|
bool dragging{};
|
|
bool rememberElevationApproval{};
|
|
HWND picker{}, pickerFrame{}, menuBar{};
|
|
HWND menuItems[5]{};
|
|
int menuIndex{};
|
|
bool commandPicker{};
|
|
int optionsPage{};
|
|
int sizeWidth=6;
|
|
bool alignExtensions=true, showDetails=true;
|
|
bool alignFolders=false;
|
|
DWORD statusFields=15;
|
|
std::vector<fs::path> drivePaths;
|
|
int pickerPanel{};
|
|
bool altAlone{};
|
|
enum Color { PanelBlue, Text, Frame, Dialog, Selection, Footer, PanelCursor, ColorCount };
|
|
COLORREF colors[]{RGB(0,0,128), RGB(230,255,255), RGB(0,255,255),
|
|
RGB(0,128,128), RGB(0,0,0), RGB(0,128,128), RGB(0,128,128)};
|
|
constexpr auto schemeKey = L"Software\\KSwitcher\\Files";
|
|
constexpr auto placementPreference = L"WindowPlacement";
|
|
|
|
bool restorePlacement(HWND window)
|
|
{
|
|
WINDOWPLACEMENT placement{};
|
|
DWORD size=sizeof(placement);
|
|
if(RegGetValueW(HKEY_CURRENT_USER,schemeKey,placementPreference,RRF_RT_REG_BINARY,
|
|
nullptr,&placement,&size)!=ERROR_SUCCESS || size!=sizeof(placement) ||
|
|
placement.length!=sizeof(placement)) return false;
|
|
const auto &rect=placement.rcNormalPosition;
|
|
if(static_cast<long long>(rect.right)-rect.left<540 ||
|
|
static_cast<long long>(rect.bottom)-rect.top<220) return false;
|
|
if(!MonitorFromRect(&rect,MONITOR_DEFAULTTONULL)) return false;
|
|
placement.flags=0;
|
|
placement.showCmd=placement.showCmd==SW_SHOWMAXIMIZED?SW_SHOWMAXIMIZED:SW_SHOWNORMAL;
|
|
if(!SetWindowPlacement(window,&placement)) return false;
|
|
ShowWindow(window,static_cast<int>(placement.showCmd));
|
|
return true;
|
|
}
|
|
|
|
void savePlacement(HWND window)
|
|
{
|
|
WINDOWPLACEMENT placement{};
|
|
placement.length=sizeof(placement);
|
|
if(!GetWindowPlacement(window,&placement)) return;
|
|
const bool maximized=IsZoomed(window) ||
|
|
(IsIconic(window) && (placement.flags&WPF_RESTORETOMAXIMIZED));
|
|
placement.showCmd=maximized?SW_SHOWMAXIMIZED:SW_SHOWNORMAL;
|
|
placement.flags=0;
|
|
RegSetKeyValueW(HKEY_CURRENT_USER,schemeKey,placementPreference,REG_BINARY,
|
|
&placement,sizeof(placement));
|
|
}
|
|
void chooseDrive(int index, bool fromMenu = false);
|
|
void openMenu(HWND window, int index, int page = 0);
|
|
void showFileDetails(const Panel &panel);
|
|
void editWideMode(HWND owner);
|
|
void layout(HWND window);
|
|
|
|
DWORD preference(const wchar_t *name, DWORD fallback)
|
|
{
|
|
DWORD value{}, size=sizeof(value);
|
|
return RegGetValueW(HKEY_CURRENT_USER,schemeKey,name,RRF_RT_REG_DWORD,nullptr,&value,&size)
|
|
== ERROR_SUCCESS ? value : fallback;
|
|
}
|
|
|
|
void savePreference(const wchar_t *name, DWORD value)
|
|
{
|
|
RegSetKeyValueW(HKEY_CURRENT_USER,schemeKey,name,REG_DWORD,&value,sizeof(value));
|
|
}
|
|
|
|
constexpr const wchar_t *panelPathKeys[]{L"LeftPath",L"RightPath"};
|
|
constexpr const wchar_t *panelCursorKeys[]{L"LeftCursor",L"RightCursor"};
|
|
|
|
fs::path savedPanelPath(const wchar_t *key)
|
|
{
|
|
DWORD size{};
|
|
if(RegGetValueW(HKEY_CURRENT_USER,schemeKey,key,RRF_RT_REG_SZ,
|
|
nullptr,nullptr,&size)!=ERROR_SUCCESS || size<sizeof(wchar_t)) return {};
|
|
std::wstring path(size/sizeof(wchar_t),L'\0');
|
|
if(RegGetValueW(HKEY_CURRENT_USER,schemeKey,key,RRF_RT_REG_SZ,
|
|
nullptr,path.data(),&size)!=ERROR_SUCCESS) return {};
|
|
path.resize(wcslen(path.c_str()));
|
|
return path;
|
|
}
|
|
|
|
void setMode(int index, bool wide)
|
|
{
|
|
panels[index].wide=wide;
|
|
savePreference(index ? L"RightWide" : L"LeftWide",wide);
|
|
layout(GetParent(panels[index].list));
|
|
InvalidateRect(panels[index].list,nullptr,TRUE);
|
|
showFileDetails(panels[active]);
|
|
}
|
|
HFONT mono{};
|
|
LOGFONTW displayFont{};
|
|
int fontPoints=110;
|
|
int textHeight=20, cellWidth=9;
|
|
constexpr UINT refreshProgressLayout=WM_APP+1;
|
|
|
|
BOOL CALLBACK updateDialogFont(HWND window,LPARAM parameter)
|
|
{
|
|
const auto old=reinterpret_cast<HFONT>(parameter);
|
|
if(reinterpret_cast<HFONT>(SendMessageW(window,WM_GETFONT,0,0))==old)
|
|
SendMessageW(window,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
|
|
return TRUE;
|
|
}
|
|
HBRUSH blue{}, teal{};
|
|
void layout(HWND window);
|
|
|
|
bool applyFont(HWND owner, LOGFONTW font, int points)
|
|
{
|
|
const auto dpi=GetDpiForWindow(owner);
|
|
font.lfHeight=-MulDiv(points,dpi,720);
|
|
font.lfWidth=0;
|
|
auto next=CreateFontIndirectW(&font);
|
|
if(!next) return false;
|
|
auto dc=GetDC(owner);
|
|
if(!dc){DeleteObject(next);return false;}
|
|
auto previous=SelectObject(dc,next);
|
|
TEXTMETRICW metrics{};
|
|
GetTextMetricsW(dc,&metrics);
|
|
SelectObject(dc,previous);
|
|
ReleaseDC(owner,dc);
|
|
textHeight=std::max(static_cast<LONG>(MulDiv(16,dpi,96)),metrics.tmHeight+MulDiv(6,dpi,96));
|
|
cellWidth=std::max(1L,metrics.tmAveCharWidth);
|
|
auto old=mono;
|
|
mono=next;
|
|
displayFont=font;
|
|
fontPoints=points;
|
|
for(auto &panel:panels)
|
|
{
|
|
if(panel.path) SendMessageW(panel.path,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
|
|
if(panel.list) SendMessageW(panel.list,LB_SETITEMHEIGHT,0,textHeight);
|
|
}
|
|
if(picker) SendMessageW(picker,LB_SETITEMHEIGHT,0,textHeight);
|
|
if(status) SendMessageW(status,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
|
|
if(old)
|
|
{
|
|
EnumThreadWindows(GetCurrentThreadId(),[](HWND window,LPARAM parameter)->BOOL
|
|
{
|
|
EnumChildWindows(window,updateDialogFont,parameter);
|
|
return TRUE;
|
|
},reinterpret_cast<LPARAM>(old));
|
|
DeleteObject(old);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void chooseDisplayFont(HWND owner)
|
|
{
|
|
auto font=displayFont;
|
|
CHOOSEFONTW dialog{};
|
|
dialog.lStructSize=sizeof(dialog);
|
|
dialog.hwndOwner=owner;
|
|
dialog.lpLogFont=&font;
|
|
dialog.Flags=CF_SCREENFONTS|CF_INITTOLOGFONTSTRUCT|CF_LIMITSIZE;
|
|
dialog.nSizeMin=8;
|
|
dialog.nSizeMax=24;
|
|
if(!ChooseFontW(&dialog)) return;
|
|
if(!applyFont(owner,font,dialog.iPointSize)) return;
|
|
savePreference(L"FontPoints",fontPoints);
|
|
RegSetKeyValueW(HKEY_CURRENT_USER,schemeKey,L"DisplayFont",REG_BINARY,&displayFont,sizeof(displayFont));
|
|
layout(owner);
|
|
RedrawWindow(owner,nullptr,nullptr,RDW_INVALIDATE|RDW_ALLCHILDREN);
|
|
}
|
|
|
|
void refreshColors()
|
|
{
|
|
if (blue) DeleteObject(blue);
|
|
if (teal) DeleteObject(teal);
|
|
blue = CreateSolidBrush(colors[PanelBlue]);
|
|
teal = CreateSolidBrush(colors[Dialog]);
|
|
}
|
|
|
|
void loadColors()
|
|
{
|
|
for (DWORD i=0; i<ColorCount; ++i)
|
|
{
|
|
auto name = std::to_wstring(i);
|
|
DWORD value{}, size=sizeof(value);
|
|
if (RegGetValueW(HKEY_CURRENT_USER, schemeKey, name.c_str(), RRF_RT_REG_DWORD,
|
|
nullptr, &value, &size)==ERROR_SUCCESS && value<=0xffffff)
|
|
colors[i]=value;
|
|
}
|
|
refreshColors();
|
|
}
|
|
|
|
void changeColor(HWND owner, int index)
|
|
{
|
|
static COLORREF custom[16]{};
|
|
CHOOSECOLORW dialog{};
|
|
dialog.lStructSize=sizeof(dialog);
|
|
dialog.hwndOwner=owner;
|
|
dialog.rgbResult=colors[index];
|
|
dialog.lpCustColors=custom;
|
|
dialog.Flags=CC_RGBINIT | CC_FULLOPEN;
|
|
if (!ChooseColorW(&dialog)) return;
|
|
colors[index]=dialog.rgbResult;
|
|
auto name=std::to_wstring(index);
|
|
const auto result=RegSetKeyValueW(HKEY_CURRENT_USER, schemeKey, name.c_str(), REG_DWORD,
|
|
&colors[index], sizeof(COLORREF));
|
|
refreshColors();
|
|
RedrawWindow(owner,nullptr,nullptr,RDW_INVALIDATE|RDW_ERASE|RDW_ALLCHILDREN);
|
|
if(result!=ERROR_SUCCESS)
|
|
MessageBoxW(owner,L"Could not save the color.",L"KSwitcher Files",MB_OK|MB_ICONWARNING);
|
|
}
|
|
|
|
void paintText(HDC dc, RECT rect, const wchar_t *text, COLORREF foreground, COLORREF background, bool right=false)
|
|
{
|
|
SetTextColor(dc, foreground);
|
|
SetBkColor(dc, background);
|
|
SelectObject(dc, mono);
|
|
auto alignment=SetTextAlign(dc,right?TA_RIGHT:TA_LEFT);
|
|
ExtTextOutW(dc,right?rect.right-5:rect.left+5,rect.top+3,ETO_OPAQUE|ETO_CLIPPED,&rect,text,lstrlenW(text),nullptr);
|
|
SetTextAlign(dc,alignment);
|
|
}
|
|
|
|
void showMenu(bool show);
|
|
|
|
void hidePicker()
|
|
{
|
|
if (!picker || !IsWindowVisible(picker)) return;
|
|
ShowWindow(picker,SW_HIDE);
|
|
ShowWindow(pickerFrame,SW_HIDE);
|
|
InvalidateRect(GetParent(picker),nullptr,FALSE);
|
|
SetFocus(panels[commandPicker ? active : pickerPanel].list);
|
|
if (IsWindowVisible(menuBar)) showMenu(true);
|
|
}
|
|
|
|
void selectDrive();
|
|
void showMenu(bool show)
|
|
{
|
|
if (show) SetWindowPos(menuBar,HWND_TOP,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE|SWP_SHOWWINDOW);
|
|
for (auto item : menuItems)
|
|
{
|
|
if (show) SetWindowPos(item,HWND_TOP,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE|SWP_SHOWWINDOW);
|
|
else ShowWindow(item,SW_HIDE);
|
|
if (show) InvalidateRect(item,nullptr,FALSE);
|
|
}
|
|
if (!show) ShowWindow(menuBar,SW_HIDE);
|
|
RedrawWindow(GetParent(menuBar),nullptr,nullptr,RDW_INVALIDATE|RDW_ALLCHILDREN);
|
|
}
|
|
LRESULT scrollList(HWND list, UINT message, WPARAM wp, LPARAM lp)
|
|
{
|
|
if (message == WM_MOUSEWHEEL)
|
|
{
|
|
int delta = GET_WHEEL_DELTA_WPARAM(wp);
|
|
int top = static_cast<int>(SendMessageW(list, LB_GETTOPINDEX, 0, 0));
|
|
int count = static_cast<int>(SendMessageW(list, LB_GETCOUNT, 0, 0));
|
|
RECT rect{};
|
|
GetClientRect(list, &rect);
|
|
int rowHeight = static_cast<int>(SendMessageW(list, LB_GETITEMHEIGHT, 0, 0));
|
|
int visible = std::max(1, static_cast<int>(rect.bottom) / std::max(1, rowHeight));
|
|
SendMessageW(list, LB_SETTOPINDEX,
|
|
std::clamp(top - (delta / WHEEL_DELTA) * 3, 0, std::max(0, count - visible)), 0);
|
|
return 0;
|
|
}
|
|
return DefSubclassProc(list, message, wp, lp);
|
|
}
|
|
|
|
void paintScrollPosition(HWND parent, HDC dc, HWND list, COLORREF background)
|
|
{
|
|
RECT track{};
|
|
GetWindowRect(list, &track);
|
|
MapWindowPoints(nullptr, parent, reinterpret_cast<POINT *>(&track), 2);
|
|
track.left = track.right;
|
|
track.right += 5;
|
|
SetDCBrushColor(dc, background);
|
|
FillRect(dc, &track, static_cast<HBRUSH>(GetStockObject(DC_BRUSH)));
|
|
int count = static_cast<int>(SendMessageW(list, LB_GETCOUNT, 0, 0));
|
|
int rowHeight = static_cast<int>(SendMessageW(list, LB_GETITEMHEIGHT, 0, 0));
|
|
int height = track.bottom - track.top;
|
|
int visible = std::max(1, height / std::max(1, rowHeight));
|
|
if (height <= 0 || count <= visible) return;
|
|
int thumb = std::min(height, std::max(5, MulDiv(height, visible, count)));
|
|
int top = static_cast<int>(SendMessageW(list, LB_GETTOPINDEX, 0, 0));
|
|
track.top += MulDiv(std::clamp(top, 0, count - visible), height - thumb, count - visible);
|
|
track.bottom = track.top + thumb;
|
|
SetDCBrushColor(dc, colors[Frame]);
|
|
FillRect(dc, &track, static_cast<HBRUSH>(GetStockObject(DC_BRUSH)));
|
|
}
|
|
|
|
void layout(HWND window)
|
|
{
|
|
RECT rect{};
|
|
GetClientRect(window, &rect);
|
|
int width = rect.right, height = rect.bottom;
|
|
int middle = std::clamp(split ? split : width / 2, 120, std::max(120, width - 120));
|
|
auto place=[](HWND control, int x, int y, int width, int height)
|
|
{
|
|
if(control) SetWindowPos(control,nullptr,x,y,width,height,
|
|
SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_NOREDRAW);
|
|
};
|
|
for (int i = 0; i < 2; ++i)
|
|
{
|
|
int x = i ? middle + 2 : 0;
|
|
int end = i ? width : middle - 2;
|
|
place(panels[i].path, x + 5, 4, std::max(0, end - x - 10), textHeight);
|
|
int headingHeight=panels[i].wide?textHeight:0;
|
|
place(panels[i].heading,x+3,textHeight+10,std::max(0,end-x-11),headingHeight);
|
|
ShowWindow(panels[i].heading,panels[i].wide?SW_SHOWNA:SW_HIDE);
|
|
place(panels[i].list, x + 3, textHeight+10+headingHeight, std::max(0, end - x - 11),
|
|
std::max(0, height-3*textHeight-24-headingHeight));
|
|
}
|
|
place(menuBar,0,0,width,textHeight+4);
|
|
const int menuEdges[]{0,7,15,27,38,46};
|
|
for(int i=0;i<5;++i)
|
|
place(menuItems[i],4+menuEdges[i]*cellWidth,0,(menuEdges[i+1]-menuEdges[i])*cellWidth,textHeight+4);
|
|
place(status, 8, height-2*textHeight-8, std::max(0, width - 16), textHeight);
|
|
for (int i = 0; i < 5; ++i)
|
|
place(commands[i], i * width / 5, height-textHeight, (i+1)*width/5-i*width/5, textHeight);
|
|
RedrawWindow(window,nullptr,nullptr,RDW_INVALIDATE|RDW_ERASE|RDW_ALLCHILDREN);
|
|
}
|
|
|
|
void setStatus(const std::wstring &message) { SetWindowTextW(status, message.c_str()); }
|
|
|
|
void showFileDetails(const Panel &panel)
|
|
{
|
|
auto row=SendMessageW(panel.list,LB_GETCURSEL,0,0);
|
|
if(!panel.wide || !showDetails || row<0 || static_cast<size_t>(row)>=panel.rows.size())
|
|
{
|
|
setStatus(L"");
|
|
return;
|
|
}
|
|
const auto &path=panel.rows[row];
|
|
WIN32_FILE_ATTRIBUTE_DATA data{};
|
|
SYSTEMTIME modified{};
|
|
wchar_t date[64]{};
|
|
if(GetFileAttributesExW(path.c_str(),GetFileExInfoStandard,&data) &&
|
|
FileTimeToSystemTime(&data.ftLastWriteTime,&modified))
|
|
{
|
|
SYSTEMTIME local{};
|
|
if(SystemTimeToTzSpecificLocalTime(nullptr,&modified,&local))
|
|
swprintf_s(date,L" %04u-%02u-%02u %02u:%02u",unsigned(local.wYear),
|
|
unsigned(local.wMonth),unsigned(local.wDay),unsigned(local.wHour),unsigned(local.wMinute));
|
|
}
|
|
std::wstring details;
|
|
if(statusFields&1) details=path.filename().wstring();
|
|
if(statusFields&2)
|
|
{
|
|
const auto &size=panel.sizes[row];
|
|
details+=L" "+(size==L"Folder" || size==L"Up"?size:formatSize(std::stoull(size)));
|
|
}
|
|
std::wstring timestamp=date;
|
|
if((statusFields&4) && timestamp.size()>=12) details+=timestamp.substr(0,12);
|
|
if((statusFields&8) && timestamp.size()>=18) details+=timestamp.substr(12);
|
|
setStatus(details);
|
|
}
|
|
|
|
void open(Panel &panel, const fs::path &directory, bool offerElevation=false)
|
|
{
|
|
const auto previousDirectory=panel.directory;
|
|
WIN32_FIND_DATAW data{};
|
|
const auto search=FindFirstFileW((directory/L"*").c_str(),&data);
|
|
auto error=search==INVALID_HANDLE_VALUE ? GetLastError() : ERROR_SUCCESS;
|
|
std::vector<fs::path> folders, files;
|
|
std::map<fs::path,FolderEntryMetadata> metadata;
|
|
if (error!=ERROR_SUCCESS && error!=ERROR_FILE_NOT_FOUND)
|
|
{
|
|
const bool denied=error==ERROR_ACCESS_DENIED;
|
|
setStatus(denied ? L"Access denied: " + directory.wstring() :
|
|
L"Cannot open folder: " + directory.wstring());
|
|
if(offerElevation && denied && !IsUserAnAdmin())
|
|
{
|
|
auto owner=GetParent(panel.list);
|
|
auto path=directory.wstring();
|
|
const TASKDIALOG_BUTTON buttons[]{{IDYES,L"Continue as administrator"},{IDCANCEL,L"Skip"}};
|
|
TASKDIALOGCONFIG dialog{};
|
|
dialog.cbSize=sizeof(dialog);
|
|
dialog.hwndParent=owner;
|
|
dialog.dwFlags=TDF_ALLOW_DIALOG_CANCELLATION|TDF_POSITION_RELATIVE_TO_WINDOW;
|
|
dialog.pszWindowTitle=L"KSwitcher Files";
|
|
dialog.pszMainInstruction=L"Windows denied access to this folder";
|
|
dialog.pszContent=path.c_str();
|
|
dialog.pszVerificationText=L"Remember Continue for this session (Windows may still ask for UAC)";
|
|
dialog.cButtons=static_cast<UINT>(std::size(buttons));
|
|
dialog.pButtons=buttons;
|
|
dialog.nDefaultButton=IDCANCEL;
|
|
BOOL skip{};
|
|
int choice=IDYES;
|
|
if(!rememberElevationApproval && FAILED(TaskDialogIndirect(&dialog,&choice,nullptr,&skip)))
|
|
choice=MessageBoxW(owner,(path+L"\n\nTry opening as administrator?").c_str(),
|
|
L"KSwitcher Files",MB_YESNO|MB_DEFBUTTON2|MB_ICONQUESTION);
|
|
if(choice==IDYES)
|
|
{
|
|
const auto result=requestElevatedFolder(owner,directory,folders,files,metadata);
|
|
SetForegroundWindow(owner);
|
|
SetFocus(panel.list);
|
|
if(result!=ERROR_SUCCESS)
|
|
{
|
|
setStatus(result==ERROR_ACCESS_DENIED ? L"Windows denied access after elevation: "+path :
|
|
L"Could not read folder as administrator ("+std::to_wstring(result)+L"): "+path);
|
|
return;
|
|
}
|
|
rememberElevationApproval=rememberElevationApproval || skip!=FALSE;
|
|
error=ERROR_SUCCESS;
|
|
}
|
|
}
|
|
if(error) return;
|
|
}
|
|
if(search!=INVALID_HANDLE_VALUE)
|
|
{
|
|
do
|
|
{
|
|
const std::wstring_view name(data.cFileName);
|
|
if(name==L"." || name==L"..") continue;
|
|
const auto path=directory/name;
|
|
const auto size=(static_cast<ULONGLONG>(data.nFileSizeHigh)<<32)|data.nFileSizeLow;
|
|
(data.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY?folders:files).push_back(path);
|
|
metadata.emplace(path,FolderEntryMetadata{data.dwFileAttributes,size});
|
|
} while(FindNextFileW(search,&data));
|
|
error=GetLastError();
|
|
FindClose(search);
|
|
}
|
|
std::sort(folders.begin(), folders.end());
|
|
std::sort(files.begin(), files.end());
|
|
panel.directory = directory;
|
|
panel.rows.clear();
|
|
panel.sizes.clear();
|
|
panel.dimmed.clear();
|
|
panel.marked.clear();
|
|
SendMessageW(panel.list, LB_RESETCONTENT, 0, 0);
|
|
auto add = [&](const fs::path &path, const std::wstring &label, bool folder)
|
|
{
|
|
if (SendMessageW(panel.list, LB_ADDSTRING, 0, reinterpret_cast<LPARAM>(label.c_str())) >= 0)
|
|
{
|
|
panel.rows.push_back(path);
|
|
panel.marked.push_back(false);
|
|
const auto entry=label==L".." ? FolderEntryMetadata{} : metadata.at(path);
|
|
panel.dimmed.push_back((entry.attributes&(FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN))!=0);
|
|
panel.sizes.push_back(folder ? (label==L".." ? L"Up" : L"Folder") :
|
|
std::to_wstring(entry.size));
|
|
}
|
|
};
|
|
if (directory.has_relative_path()) add(directory.parent_path(), L"..", true);
|
|
for (const auto &folder : folders) add(folder, L"[" + folder.filename().wstring() + L"]", true);
|
|
for (const auto &file : files) add(file, file.filename().wstring(), false);
|
|
SetWindowTextW(panel.path, directory.c_str());
|
|
auto selected=panel.rows.begin();
|
|
if(!previousDirectory.empty() && previousDirectory.parent_path()==directory)
|
|
{
|
|
const auto child=std::find(panel.rows.begin(),panel.rows.end(),previousDirectory);
|
|
if(child!=panel.rows.end()) selected=child;
|
|
}
|
|
SendMessageW(panel.list,LB_SETCURSEL,selected-panel.rows.begin(),0);
|
|
if(error!=ERROR_SUCCESS && error!=ERROR_NO_MORE_FILES && error!=ERROR_FILE_NOT_FOUND)
|
|
setStatus(L"Some entries could not be read.");
|
|
else showFileDetails(panel);
|
|
}
|
|
|
|
void selectDrive()
|
|
{
|
|
auto row=SendMessageW(picker,LB_GETCURSEL,0,0);
|
|
hidePicker();
|
|
showMenu(false);
|
|
if(commandPicker)
|
|
{
|
|
if(row<0) return;
|
|
auto owner=GetParent(picker);
|
|
if(menuIndex==0 || menuIndex==4)
|
|
{
|
|
int index=menuIndex==4;
|
|
if(row==2) chooseDrive(index);
|
|
else setMode(index,row==1);
|
|
}
|
|
else if(menuIndex==3)
|
|
{
|
|
if(optionsPage==0)
|
|
{
|
|
if(row==2) chooseDisplayFont(owner);
|
|
else openMenu(owner,3,row==0?1:2);
|
|
}
|
|
else if(optionsPage==1) editWideMode(owner);
|
|
else if(optionsPage==2) changeColor(owner,static_cast<int>(row));
|
|
}
|
|
else
|
|
{
|
|
const int command=menuIndex==1?113+static_cast<int>(row):110+static_cast<int>(row);
|
|
SendMessageW(owner,WM_COMMAND,MAKEWPARAM(command,BN_CLICKED),0);
|
|
}
|
|
return;
|
|
}
|
|
if(row>=0 && static_cast<size_t>(row)<drivePaths.size()) open(panels[pickerPanel],drivePaths[row]);
|
|
}
|
|
|
|
LRESULT CALLBACK pickerKeys(HWND window, UINT msg, WPARAM wp, LPARAM lp, UINT_PTR, DWORD_PTR)
|
|
{
|
|
if(msg==WM_KEYDOWN && wp==VK_ESCAPE)
|
|
{
|
|
if(commandPicker && menuIndex==3 && optionsPage)
|
|
openMenu(GetParent(window),3);
|
|
else hidePicker();
|
|
return 0;
|
|
}
|
|
if(msg==WM_KEYDOWN && wp==VK_RETURN){selectDrive();return 0;}
|
|
if(msg==WM_KEYDOWN && (wp==VK_LEFT || wp==VK_RIGHT) && IsWindowVisible(menuBar))
|
|
{
|
|
int next=(menuIndex+(wp==VK_LEFT?4:1))%5;
|
|
SendMessageW(GetParent(window),WM_COMMAND,MAKEWPARAM(130+next,BN_CLICKED),0);
|
|
return 0;
|
|
}
|
|
return scrollList(window,msg,wp,lp);
|
|
}
|
|
|
|
void chooseDrive(int index, bool fromMenu)
|
|
{
|
|
commandPicker=false;
|
|
if (!fromMenu) showMenu(false);
|
|
pickerPanel=index;
|
|
drivePaths.clear();
|
|
SendMessageW(picker,LB_RESETCONTENT,0,0);
|
|
const DWORD disks=GetLogicalDrives();
|
|
int selected=0;
|
|
int textWidth=0;
|
|
auto dc=GetDC(picker);
|
|
auto oldFont=dc ? SelectObject(dc,mono) : nullptr;
|
|
for(int letter=0;letter<26;++letter)
|
|
{
|
|
if(!(disks & (1UL<<letter))) continue;
|
|
wchar_t drive[]{static_cast<wchar_t>(L'A'+letter),L':',L'\\',0};
|
|
wchar_t volume[MAX_PATH]{};
|
|
const auto type=GetDriveTypeW(drive);
|
|
ULARGE_INTEGER total{}, free{};
|
|
if(type==DRIVE_FIXED || type==DRIVE_RAMDISK)
|
|
{
|
|
GetVolumeInformationW(drive,volume,MAX_PATH,nullptr,nullptr,nullptr,nullptr,0);
|
|
GetDiskFreeSpaceExW(drive,&free,&total,nullptr);
|
|
}
|
|
std::wostringstream columns;
|
|
columns << drive << L" " << std::left << std::setw(8) << std::wstring(volume).substr(0, 8);
|
|
if(total.QuadPart)
|
|
columns << L" " << std::right << std::setw(12) << formatSize(total.QuadPart)
|
|
<< L" | " << std::setw(12) << formatSize(free.QuadPart) << L" free";
|
|
auto label=columns.str();
|
|
SIZE extent{};
|
|
if(dc && GetTextExtentPoint32W(dc,label.c_str(),static_cast<int>(label.size()),&extent))
|
|
textWidth=std::max(textWidth,static_cast<int>(extent.cx));
|
|
if(fs::path(drive)==panels[index].directory.root_path()) selected=static_cast<int>(drivePaths.size());
|
|
SendMessageW(picker,LB_ADDSTRING,0,reinterpret_cast<LPARAM>(label.c_str()));
|
|
drivePaths.emplace_back(drive);
|
|
}
|
|
if(dc)
|
|
{
|
|
if(oldFont) SelectObject(dc,oldFont);
|
|
ReleaseDC(picker,dc);
|
|
}
|
|
if(drivePaths.empty()) return;
|
|
HWND owner=GetParent(picker);
|
|
RECT panel{};
|
|
GetWindowRect(panels[index].list,&panel);
|
|
MapWindowPoints(nullptr,owner,reinterpret_cast<POINT*>(&panel),2);
|
|
const int panelWidth=panel.right-panel.left;
|
|
const int width=std::clamp(textWidth+24,90,std::max(90,panelWidth*4/5-12));
|
|
const int height=std::min(7,static_cast<int>(drivePaths.size()))*textHeight;
|
|
const int x=panel.left+(panel.right-panel.left-width)/2;
|
|
const int y=panel.top+(panel.bottom-panel.top-height)/2;
|
|
SetWindowPos(pickerFrame,HWND_TOP,x-6,y-textHeight-4,width+12,height+textHeight+11,SWP_SHOWWINDOW);
|
|
SetWindowPos(picker,HWND_TOP,x,y,width-5,height,SWP_SHOWWINDOW);
|
|
SendMessageW(picker,LB_SETCURSEL,selected,0);
|
|
SetFocus(picker);
|
|
if (fromMenu) showMenu(true);
|
|
RedrawWindow(owner,nullptr,nullptr,RDW_INVALIDATE|RDW_ALLCHILDREN|RDW_UPDATENOW);
|
|
}
|
|
|
|
void enter(Panel &panel)
|
|
{
|
|
auto row = SendMessageW(panel.list, LB_GETCURSEL, 0, 0);
|
|
if (row >= 0 && static_cast<size_t>(row) < panel.rows.size())
|
|
{
|
|
auto target = panel.rows[row];
|
|
if(panel.sizes[row]==L"Folder" || panel.sizes[row]==L"Up") open(panel,target,true);
|
|
}
|
|
}
|
|
|
|
enum class ConflictMode { ask, overwrite, skip, rename, append, newer };
|
|
|
|
struct CopyRequest
|
|
{
|
|
std::vector<fs::path> sources;
|
|
fs::path destination;
|
|
fs::path newName;
|
|
ConflictMode conflictMode{};
|
|
bool askReadOnly=true;
|
|
};
|
|
|
|
HBRUSH warningBrush{};
|
|
|
|
void prepareCopyDialog(HWND dialog)
|
|
{
|
|
const auto style=GetWindowLongPtrW(dialog,GWL_STYLE);
|
|
SetWindowLongPtrW(dialog,GWL_STYLE,style&~(WS_CAPTION|WS_SYSMENU|WS_THICKFRAME));
|
|
const auto extended=GetWindowLongPtrW(dialog,GWL_EXSTYLE);
|
|
SetWindowLongPtrW(dialog,GWL_EXSTYLE,extended&~WS_EX_DLGMODALFRAME);
|
|
SetWindowPos(dialog,nullptr,0,0,0,0,
|
|
SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_FRAMECHANGED);
|
|
}
|
|
|
|
constexpr LONG dialogFrameInset=10;
|
|
|
|
RECT dialogControlBounds(HWND dialog,int id)
|
|
{
|
|
RECT bounds{};
|
|
GetWindowRect(GetDlgItem(dialog,id),&bounds);
|
|
MapWindowPoints(nullptr,dialog,reinterpret_cast<POINT*>(&bounds),2);
|
|
return bounds;
|
|
}
|
|
|
|
LONG dialogDividerY(HWND dialog,int id)
|
|
{
|
|
const auto bounds=dialogControlBounds(dialog,id);
|
|
if(id==214)
|
|
{
|
|
const auto combo=dialogControlBounds(dialog,213);
|
|
const auto name=dialogControlBounds(dialog,211);
|
|
return bounds.bottom+std::max(0L,(combo.top-name.bottom-1)/2);
|
|
}
|
|
if(id==213) return (dialogControlBounds(dialog,211).bottom+bounds.top-1)/2;
|
|
return bounds.top-4;
|
|
}
|
|
|
|
void centerDialogRow(HWND dialog,int upperDivider,int lowerDivider,std::initializer_list<int> controls)
|
|
{
|
|
RECT client{};
|
|
GetClientRect(dialog,&client);
|
|
const auto top=dialogDividerY(dialog,upperDivider)+1;
|
|
const auto bottom=lowerDivider?dialogDividerY(dialog,lowerDivider):client.bottom-dialogFrameInset;
|
|
for(const auto id:controls)
|
|
{
|
|
const auto bounds=dialogControlBounds(dialog,id);
|
|
SetWindowPos(GetDlgItem(dialog,id),nullptr,bounds.left,(top+bottom-(bounds.bottom-bounds.top))/2,
|
|
0,0,SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE);
|
|
}
|
|
}
|
|
|
|
void layoutDialogButtons(HWND dialog,int divider,std::initializer_list<int> controls)
|
|
{
|
|
RECT client{},window{};
|
|
GetClientRect(dialog,&client);
|
|
GetWindowRect(dialog,&window);
|
|
const auto footerHeight=2*static_cast<LONG>(textHeight);
|
|
const auto height=dialogDividerY(dialog,divider)+1+footerHeight+dialogFrameInset;
|
|
const auto width=window.right-window.left;
|
|
const auto outerHeight=window.bottom-window.top+height-client.bottom;
|
|
RECT owner{};
|
|
const bool centered=GetWindowRect(GetWindow(dialog,GW_OWNER),&owner)!=FALSE;
|
|
SetWindowPos(dialog,nullptr,(owner.left+owner.right-width)/2,
|
|
(owner.top+owner.bottom-outerHeight)/2,width,outerHeight,
|
|
(centered?0:SWP_NOMOVE)|SWP_NOZORDER|SWP_NOACTIVATE);
|
|
centerDialogRow(dialog,divider,0,controls);
|
|
}
|
|
|
|
void paintDialogButton(const DRAWITEMSTRUCT &item,COLORREF surface,COLORREF foreground)
|
|
{
|
|
wchar_t label[32]{};
|
|
GetWindowTextW(item.hwndItem,label,static_cast<int>(std::size(label)));
|
|
const bool focused=(item.itemState&(ODS_FOCUS|ODS_SELECTED))!=0;
|
|
SetDCBrushColor(item.hDC,focused?colors[Dialog]:surface);
|
|
FillRect(item.hDC,&item.rcItem,static_cast<HBRUSH>(GetStockObject(DC_BRUSH)));
|
|
SelectObject(item.hDC,mono);
|
|
SetBkMode(item.hDC,TRANSPARENT);
|
|
SetTextColor(item.hDC,focused?colors[Text]:foreground);
|
|
auto rect=item.rcItem;
|
|
const auto caption=L"[ "+std::wstring(label)+L" ]";
|
|
DrawTextW(item.hDC,caption.c_str(),-1,&rect,DT_CENTER|DT_VCENTER|DT_SINGLELINE);
|
|
}
|
|
|
|
INT_PTR paintCopyDialog(HWND dialog, UINT message, WPARAM wp, LPARAM lp,
|
|
const wchar_t *caption, bool warning, std::initializer_list<int> dividers)
|
|
{
|
|
const auto foreground=warning?RGB(255,255,255):RGB(0,0,0);
|
|
const auto surface=warning?RGB(128,0,0):RGB(192,192,192);
|
|
const auto brush=warning?warningBrush:static_cast<HBRUSH>(GetStockObject(LTGRAY_BRUSH));
|
|
if(message==WM_CTLCOLORDLG) return reinterpret_cast<INT_PTR>(brush);
|
|
if(message==WM_CTLCOLORSTATIC || message==WM_CTLCOLOREDIT || message==WM_CTLCOLORBTN)
|
|
{
|
|
const auto dc=reinterpret_cast<HDC>(wp);
|
|
const bool edit=reinterpret_cast<HWND>(lp)==GetDlgItem(dialog,211);
|
|
SetTextColor(dc,edit?colors[Text]:foreground);
|
|
SetBkColor(dc,edit?colors[Dialog]:surface);
|
|
return reinterpret_cast<INT_PTR>(edit?teal:brush);
|
|
}
|
|
if(message==WM_PAINT)
|
|
{
|
|
PAINTSTRUCT paint{};
|
|
const auto dc=BeginPaint(dialog,&paint);
|
|
RECT bounds{};
|
|
GetClientRect(dialog,&bounds);
|
|
FillRect(dc,&bounds,brush);
|
|
InflateRect(&bounds,-8,-8);
|
|
const auto black=static_cast<HBRUSH>(GetStockObject(warning?WHITE_BRUSH:BLACK_BRUSH));
|
|
FrameRect(dc,&bounds,black);
|
|
InflateRect(&bounds,-2,-2);
|
|
FrameRect(dc,&bounds,black);
|
|
for(const auto control:dividers)
|
|
{
|
|
const auto y=dialogDividerY(dialog,control);
|
|
RECT divider{bounds.left+1,y,bounds.right-1,y+1};
|
|
FillRect(dc,÷r,black);
|
|
}
|
|
SelectObject(dc,mono);
|
|
RECT title{};
|
|
DrawTextW(dc,caption,-1,&title,DT_CALCRECT|DT_SINGLELINE|DT_NOPREFIX);
|
|
const auto titleHeight=title.bottom;
|
|
const auto top=std::max(0L,bounds.top-titleHeight/2);
|
|
title={bounds.left,top,bounds.right,top+titleHeight};
|
|
SetTextColor(dc,foreground);
|
|
SetBkColor(dc,surface);
|
|
DrawTextW(dc,caption,-1,&title,DT_CENTER|DT_SINGLELINE|DT_VCENTER|DT_NOPREFIX);
|
|
EndPaint(dialog,&paint);
|
|
return TRUE;
|
|
}
|
|
if(message==WM_DRAWITEM)
|
|
{
|
|
const auto &item=*reinterpret_cast<const DRAWITEMSTRUCT*>(lp);
|
|
paintDialogButton(item,surface,foreground);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT CALLBACK paintConflictCombo(HWND control,UINT message,WPARAM wp,LPARAM lp,UINT_PTR,DWORD_PTR)
|
|
{
|
|
if(message!=WM_PAINT) return DefSubclassProc(control,message,wp,lp);
|
|
PAINTSTRUCT paint{};
|
|
const auto dc=BeginPaint(control,&paint);
|
|
RECT bounds{};
|
|
GetClientRect(control,&bounds);
|
|
wchar_t label[64]{};
|
|
const auto selected=SendMessageW(control,CB_GETCURSEL,0,0);
|
|
if(selected!=CB_ERR) SendMessageW(control,CB_GETLBTEXT,selected,reinterpret_cast<LPARAM>(label));
|
|
auto arrow=bounds;
|
|
arrow.left=std::max(bounds.left,bounds.right-2*static_cast<LONG>(cellWidth));
|
|
bounds.right=arrow.left;
|
|
SetDCBrushColor(dc,colors[Dialog]);
|
|
FillRect(dc,&bounds,static_cast<HBRUSH>(GetStockObject(DC_BRUSH)));
|
|
FillRect(dc,&arrow,static_cast<HBRUSH>(GetStockObject(DC_BRUSH)));
|
|
SelectObject(dc,mono);
|
|
SetBkMode(dc,TRANSPARENT);
|
|
SetTextColor(dc,colors[Text]);
|
|
bounds.left+=5;
|
|
DrawTextW(dc,label,-1,&bounds,DT_SINGLELINE|DT_VCENTER|DT_END_ELLIPSIS|DT_NOPREFIX);
|
|
DrawTextW(dc,L"↓",-1,&arrow,DT_SINGLELINE|DT_VCENTER|DT_CENTER);
|
|
if(GetFocus()==control) DrawFocusRect(dc,&bounds);
|
|
EndPaint(control,&paint);
|
|
return 0;
|
|
}
|
|
|
|
INT_PTR CALLBACK copyDialog(HWND dialog, UINT message, WPARAM wp, LPARAM lp)
|
|
{
|
|
constexpr int summary=210, pathField=211, conflicts=212;
|
|
if(message==WM_DRAWITEM && wp==214)
|
|
{
|
|
const auto &item=*reinterpret_cast<const DRAWITEMSTRUCT*>(lp);
|
|
const auto request=reinterpret_cast<const CopyRequest*>(GetWindowLongPtrW(dialog,DWLP_USER));
|
|
const bool checked=request && request->askReadOnly;
|
|
paintText(item.hDC,item.rcItem,checked?L"[x] Also ask on read-only files":
|
|
L"[ ] Also ask on read-only files",RGB(0,0,0),RGB(192,192,192));
|
|
if(item.itemState&ODS_FOCUS) DrawFocusRect(item.hDC,&item.rcItem);
|
|
return TRUE;
|
|
}
|
|
if(message==WM_DRAWITEM && wp==213)
|
|
{
|
|
const auto &item=*reinterpret_cast<const DRAWITEMSTRUCT*>(lp);
|
|
wchar_t label[64]{};
|
|
if(item.itemID!=UINT(-1))
|
|
SendMessageW(item.hwndItem,CB_GETLBTEXT,item.itemID,reinterpret_cast<LPARAM>(label));
|
|
const bool selected=(item.itemState&ODS_SELECTED)!=0 && (item.itemState&ODS_COMBOBOXEDIT)==0;
|
|
paintText(item.hDC,item.rcItem,label,colors[Text],colors[selected?Selection:Dialog]);
|
|
return TRUE;
|
|
}
|
|
if(message==WM_CTLCOLORLISTBOX)
|
|
{
|
|
const auto dc=reinterpret_cast<HDC>(wp);
|
|
SetTextColor(dc,colors[Text]);
|
|
SetBkColor(dc,colors[Dialog]);
|
|
return reinterpret_cast<INT_PTR>(teal);
|
|
}
|
|
if(const auto painted=paintCopyDialog(dialog,message,wp,lp,L" Copy ",false,{213,214}))
|
|
return painted;
|
|
if(message==WM_INITDIALOG)
|
|
{
|
|
auto &request=*reinterpret_cast<CopyRequest*>(lp);
|
|
prepareCopyDialog(dialog);
|
|
SetWindowLongPtrW(dialog,DWLP_USER,lp);
|
|
for(const auto label:{L"Ask",L"Overwrite",L"Skip",L"Rename",L"Append",L"Only newer file(s)"})
|
|
SendDlgItemMessageW(dialog,213,CB_ADDSTRING,0,reinterpret_cast<LPARAM>(label));
|
|
SendDlgItemMessageW(dialog,213,CB_SETCURSEL,0,0);
|
|
const auto label=request.sources.size()==1 ?
|
|
L"Copy "+request.sources.front().filename().wstring()+L" to:" :
|
|
L"Copy "+std::to_wstring(request.sources.size())+L" items to:";
|
|
SetDlgItemTextW(dialog,summary,label.c_str());
|
|
const bool single=request.sources.size()==1;
|
|
const auto fieldText=single?request.sources.front().filename():request.destination;
|
|
SetDlgItemTextW(dialog,pathField,fieldText.c_str());
|
|
SendDlgItemMessageW(dialog,pathField,EM_SETREADONLY,!single,0);
|
|
SendDlgItemMessageW(dialog,pathField,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
|
|
RECT edit{};
|
|
GetClientRect(GetDlgItem(dialog,pathField),&edit);
|
|
const auto field=GetDlgItem(dialog,pathField);
|
|
if(const auto dc=GetDC(field))
|
|
{
|
|
const auto oldFont=SelectObject(dc,mono);
|
|
TEXTMETRICW metrics{};
|
|
if(GetTextMetricsW(dc,&metrics))
|
|
edit.top=std::max(0L,(edit.bottom-metrics.tmHeight)/2);
|
|
SelectObject(dc,oldFont);
|
|
ReleaseDC(field,dc);
|
|
}
|
|
edit.left+=2;
|
|
edit.right-=2;
|
|
SendDlgItemMessageW(dialog,pathField,EM_SETRECT,0,reinterpret_cast<LPARAM>(&edit));
|
|
layoutDialogButtons(dialog,214,{IDOK,IDCANCEL});
|
|
SendDlgItemMessageW(dialog,summary,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
|
|
SendDlgItemMessageW(dialog,conflicts,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
|
|
for(const auto control:{213,214})
|
|
SendDlgItemMessageW(dialog,control,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
|
|
SendDlgItemMessageW(dialog,213,CB_SETITEMHEIGHT,0,textHeight);
|
|
SendDlgItemMessageW(dialog,213,CB_SETITEMHEIGHT,static_cast<WPARAM>(-1),textHeight+2);
|
|
RECT combo{}, caption{};
|
|
const auto captionControl=GetDlgItem(dialog,conflicts);
|
|
GetWindowRect(GetDlgItem(dialog,213),&combo);
|
|
GetWindowRect(captionControl,&caption);
|
|
MapWindowPoints(nullptr,dialog,reinterpret_cast<POINT*>(&combo),2);
|
|
MapWindowPoints(nullptr,dialog,reinterpret_cast<POINT*>(&caption),2);
|
|
SetWindowPos(captionControl,nullptr,caption.left,combo.top,
|
|
caption.right-caption.left,combo.bottom-combo.top,SWP_NOZORDER|SWP_NOACTIVATE);
|
|
SetWindowSubclass(GetDlgItem(dialog,213),paintConflictCombo,1,0);
|
|
SendMessageW(dialog,DM_SETDEFID,IDOK,0);
|
|
SendDlgItemMessageW(dialog,pathField,EM_SETSEL,0,-1);
|
|
return TRUE;
|
|
}
|
|
if(message==WM_CLOSE || (message==WM_COMMAND && LOWORD(wp)==IDCANCEL))
|
|
{
|
|
EndDialog(dialog,IDCANCEL);
|
|
return TRUE;
|
|
}
|
|
if(message!=WM_COMMAND) return FALSE;
|
|
auto &request=*reinterpret_cast<CopyRequest*>(GetWindowLongPtrW(dialog,DWLP_USER));
|
|
if(LOWORD(wp)==214 && HIWORD(wp)==BN_CLICKED)
|
|
{
|
|
request.askReadOnly=!request.askReadOnly;
|
|
InvalidateRect(GetDlgItem(dialog,214),nullptr,FALSE);
|
|
return TRUE;
|
|
}
|
|
if(LOWORD(wp)==213)
|
|
{
|
|
InvalidateRect(GetDlgItem(dialog,213),nullptr,FALSE);
|
|
return FALSE;
|
|
}
|
|
if(LOWORD(wp)!=IDOK) return FALSE;
|
|
if(request.sources.size()==1)
|
|
{
|
|
const auto field=GetDlgItem(dialog,pathField);
|
|
std::wstring name(GetWindowTextLengthW(field)+1,L'\0');
|
|
name.resize(GetWindowTextW(field,name.data(),static_cast<int>(name.size())));
|
|
if(name.empty() || name.back()==L'.' || name.back()==L' ' ||
|
|
name.find_first_of(L"<>:\"/\\|?*")!=name.npos ||
|
|
std::any_of(name.begin(),name.end(),[](wchar_t ch){return ch<32;}))
|
|
{
|
|
MessageBoxW(dialog,L"Enter a valid name for the copy.",L"Copy",MB_OK|MB_ICONWARNING);
|
|
SetFocus(field);
|
|
return TRUE;
|
|
}
|
|
if(CompareStringOrdinal(name.c_str(),-1,request.sources.front().filename().c_str(),-1,TRUE)!=CSTR_EQUAL)
|
|
request.newName=name;
|
|
else request.newName.clear();
|
|
}
|
|
const auto sourceDirectory=request.sources.front().parent_path();
|
|
const auto destination=request.newName.empty()?request.destination:sourceDirectory;
|
|
std::error_code error;
|
|
if(!fs::is_directory(destination,error))
|
|
{
|
|
MessageBoxW(dialog,L"The destination folder is unavailable.",L"Copy",MB_OK|MB_ICONWARNING);
|
|
return TRUE;
|
|
}
|
|
if(request.newName.empty() && fs::equivalent(destination,sourceDirectory,error))
|
|
{
|
|
MessageBoxW(dialog,L"Open a different folder in the other panel, or enter a new name for a single item.",
|
|
L"Copy",MB_OK|MB_ICONWARNING);
|
|
return TRUE;
|
|
}
|
|
const auto mode=SendDlgItemMessageW(dialog,213,CB_GETCURSEL,0,0);
|
|
if(mode!=CB_ERR) request.conflictMode=static_cast<ConflictMode>(mode);
|
|
EndDialog(dialog,IDOK);
|
|
return TRUE;
|
|
}
|
|
|
|
struct CopyProgress
|
|
{
|
|
HWND window{};
|
|
bool canceled{};
|
|
bool closeOwner{};
|
|
int conflictChoice{};
|
|
ConflictMode conflictMode{};
|
|
bool askReadOnly=true;
|
|
uint64_t files{}, totalFiles{}, bytes{}, totalBytes{};
|
|
uint64_t skippedFiles{}, skippedBytes{};
|
|
const wchar_t *lastSkipReason=L"";
|
|
ULONGLONG lastPaint{};
|
|
fs::path from,to;
|
|
};
|
|
bool copyInProgress{};
|
|
CopyProgress *activeCopy{};
|
|
RECT previousOwnerBounds{};
|
|
|
|
struct OwnedWindowMove
|
|
{
|
|
HWND owner;
|
|
LONG dx,dy;
|
|
};
|
|
|
|
BOOL CALLBACK moveOwnedDialog(HWND window,LPARAM parameter)
|
|
{
|
|
const auto &move=*reinterpret_cast<const OwnedWindowMove*>(parameter);
|
|
if(window==move.owner || !IsWindowVisible(window) ||
|
|
GetAncestor(window,GA_ROOTOWNER)!=move.owner) return TRUE;
|
|
RECT bounds{};
|
|
if(GetWindowRect(window,&bounds))
|
|
SetWindowPos(window,nullptr,bounds.left+move.dx,bounds.top+move.dy,0,0,
|
|
SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE);
|
|
return TRUE;
|
|
}
|
|
|
|
LRESULT CALLBACK paintCopyProgressBar(HWND bar,UINT message,WPARAM wp,LPARAM lp,UINT_PTR,DWORD_PTR)
|
|
{
|
|
if(message!=WM_PAINT) return DefSubclassProc(bar,message,wp,lp);
|
|
PAINTSTRUCT paint{};
|
|
const auto dc=BeginPaint(bar,&paint);
|
|
RECT bounds{};
|
|
GetClientRect(bar,&bounds);
|
|
const auto percent=std::clamp(SendMessageW(bar,PBM_GETPOS,0,0),LRESULT{0},LRESULT{100});
|
|
auto filled=bounds;
|
|
filled.right=static_cast<LONG>(bounds.right*percent/100);
|
|
FillRect(dc,&bounds,static_cast<HBRUSH>(GetStockObject(WHITE_BRUSH)));
|
|
FillRect(dc,&filled,static_cast<HBRUSH>(GetStockObject(BLACK_BRUSH)));
|
|
const auto label=std::to_wstring(percent)+L"%";
|
|
SelectObject(dc,mono);
|
|
SetBkMode(dc,TRANSPARENT);
|
|
constexpr auto flags=DT_CENTER|DT_VCENTER|DT_SINGLELINE|DT_NOPREFIX;
|
|
SetTextColor(dc,RGB(0,0,0));
|
|
auto labelBounds=bounds;
|
|
DrawTextW(dc,label.c_str(),-1,&labelBounds,flags);
|
|
const auto saved=SaveDC(dc);
|
|
if(saved)
|
|
{
|
|
IntersectClipRect(dc,filled.left,filled.top,filled.right,filled.bottom);
|
|
SetTextColor(dc,RGB(255,255,255));
|
|
labelBounds=bounds;
|
|
DrawTextW(dc,label.c_str(),-1,&labelBounds,flags);
|
|
RestoreDC(dc,saved);
|
|
}
|
|
EndPaint(bar,&paint);
|
|
return 0;
|
|
}
|
|
|
|
void updateCopyProgress(CopyProgress &progress,uint64_t current,uint64_t fileSize,bool force=false)
|
|
{
|
|
constexpr ULONGLONG refreshIntervalMs=200;
|
|
const auto now=GetTickCount64();
|
|
if(!force && now-progress.lastPaint<refreshIntervalMs) return;
|
|
progress.lastPaint=now;
|
|
if(!progress.from.empty())
|
|
{
|
|
SetDlgItemTextW(progress.window,220,(L"From: "+progress.from.wstring()).c_str());
|
|
SetDlgItemTextW(progress.window,221,(L"To: "+progress.to.wstring()).c_str());
|
|
for(const auto id:{220,221}) InvalidateRect(GetDlgItem(progress.window,id),nullptr,FALSE);
|
|
}
|
|
const auto percent=[](uint64_t done,uint64_t total)
|
|
{
|
|
return total?static_cast<int>(100.0*std::min(done,total)/total):0;
|
|
};
|
|
const auto updateBar=[&](int bar,int value)
|
|
{
|
|
const auto control=GetDlgItem(progress.window,bar);
|
|
SendMessageW(control,PBM_SETPOS,value,0);
|
|
InvalidateRect(control,nullptr,FALSE);
|
|
};
|
|
const auto bytes=progress.bytes+current;
|
|
updateBar(222,fileSize?percent(current,fileSize):0);
|
|
updateBar(226,progress.totalBytes?
|
|
percent(bytes+progress.skippedBytes,progress.totalBytes):
|
|
percent(progress.files+progress.skippedFiles,progress.totalFiles));
|
|
SetDlgItemTextW(progress.window,224,(L"Files: "+std::to_wstring(progress.files)+L" / "+
|
|
std::to_wstring(progress.totalFiles)+(progress.skippedFiles?
|
|
L" Skipped: "+std::to_wstring(progress.skippedFiles)+L" ("+progress.lastSkipReason+L")":L"")).c_str());
|
|
SetDlgItemTextW(progress.window,225,(L"Size: "+formatSize(bytes)+L" / "+
|
|
formatSize(progress.totalBytes)).c_str());
|
|
}
|
|
|
|
INT_PTR CALLBACK cancelCopyDialog(HWND window,UINT message,WPARAM wp,LPARAM lp)
|
|
{
|
|
if(const auto painted=paintCopyDialog(window,message,wp,lp,L" Operation interrupted ",true,{236}))
|
|
return painted;
|
|
if(message==WM_INITDIALOG)
|
|
{
|
|
prepareCopyDialog(window);
|
|
SendDlgItemMessageW(window,235,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
|
|
layoutDialogButtons(window,236,{IDYES,IDNO});
|
|
SendMessageW(window,DM_SETDEFID,IDNO,0);
|
|
SetFocus(GetDlgItem(window,IDNO));
|
|
return FALSE;
|
|
}
|
|
if(message==WM_CLOSE || (message==WM_COMMAND &&
|
|
(LOWORD(wp)==IDYES || LOWORD(wp)==IDNO || LOWORD(wp)==IDCANCEL)))
|
|
{
|
|
EndDialog(window,message==WM_COMMAND && LOWORD(wp)==IDYES?IDYES:IDNO);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
INT_PTR CALLBACK copyProgressDialog(HWND window,UINT message,WPARAM wp,LPARAM lp)
|
|
{
|
|
if(message==WM_DRAWITEM && (wp==220 || wp==221))
|
|
{
|
|
const auto &item=*reinterpret_cast<const DRAWITEMSTRUCT*>(lp);
|
|
std::wstring path(GetWindowTextLengthW(item.hwndItem)+1,L'\0');
|
|
GetWindowTextW(item.hwndItem,path.data(),static_cast<int>(path.size()));
|
|
auto bounds=item.rcItem;
|
|
FillRect(item.hDC,&bounds,static_cast<HBRUSH>(GetStockObject(LTGRAY_BRUSH)));
|
|
SelectObject(item.hDC,mono);
|
|
SetBkMode(item.hDC,TRANSPARENT);
|
|
SetTextColor(item.hDC,RGB(0,0,0));
|
|
constexpr auto flags=DT_SINGLELINE|DT_VCENTER|DT_NOPREFIX;
|
|
const int prefix=wp==220?6:4;
|
|
if(GetWindowTextLengthW(item.hwndItem)>prefix && path[prefix-2]==L':')
|
|
{
|
|
SIZE width{};
|
|
GetTextExtentPoint32W(item.hDC,path.data(),prefix,&width);
|
|
DrawTextW(item.hDC,path.data(),prefix,&bounds,flags);
|
|
bounds.left+=width.cx;
|
|
DrawTextW(item.hDC,path.data()+prefix,-1,&bounds,flags|DT_PATH_ELLIPSIS|DT_END_ELLIPSIS);
|
|
}
|
|
else DrawTextW(item.hDC,path.data(),-1,&bounds,flags|DT_END_ELLIPSIS);
|
|
return TRUE;
|
|
}
|
|
if(const auto painted=paintCopyDialog(window,message,wp,lp,L" Copy ",false,{228,229}))
|
|
return painted;
|
|
if(message==WM_DPICHANGED)
|
|
{
|
|
PostMessageW(window,refreshProgressLayout,0,0);
|
|
return FALSE;
|
|
}
|
|
if(message==WM_INITDIALOG || message==refreshProgressLayout)
|
|
{
|
|
if(message==WM_INITDIALOG)
|
|
{
|
|
prepareCopyDialog(window);
|
|
SetWindowLongPtrW(window,DWLP_USER,lp);
|
|
}
|
|
for(const auto control:{220,221,224,225})
|
|
{
|
|
SendDlgItemMessageW(window,control,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
|
|
const auto bounds=dialogControlBounds(window,control);
|
|
SetWindowPos(GetDlgItem(window,control),nullptr,0,0,bounds.right-bounds.left,textHeight,
|
|
SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
|
|
}
|
|
for(const auto id:{222,226})
|
|
{
|
|
const auto bar=GetDlgItem(window,id);
|
|
const auto bounds=dialogControlBounds(window,id);
|
|
SetWindowPos(bar,nullptr,0,0,bounds.right-bounds.left,textHeight+8,
|
|
SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
|
|
SetWindowSubclass(bar,paintCopyProgressBar,1,0);
|
|
}
|
|
const auto moveRow=[&](int id,LONG top)
|
|
{
|
|
const auto bounds=dialogControlBounds(window,id);
|
|
SetWindowPos(GetDlgItem(window,id),nullptr,bounds.left,top,0,0,
|
|
SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE);
|
|
};
|
|
const auto padding=dialogControlBounds(window,220).top-dialogFrameInset-1;
|
|
moveRow(221,std::max(dialogControlBounds(window,221).top,dialogControlBounds(window,220).bottom));
|
|
moveRow(222,std::max(dialogControlBounds(window,222).top,dialogControlBounds(window,221).bottom+4));
|
|
const auto firstBottom=dialogControlBounds(window,222).bottom;
|
|
moveRow(228,firstBottom+padding+4);
|
|
const auto offset=dialogDividerY(window,228)+1+padding-dialogControlBounds(window,224).top;
|
|
for(const auto id:{224,225,226})
|
|
moveRow(id,dialogControlBounds(window,id).top+offset);
|
|
moveRow(225,std::max(dialogControlBounds(window,225).top,dialogControlBounds(window,224).bottom));
|
|
moveRow(226,std::max(dialogControlBounds(window,226).top,dialogControlBounds(window,225).bottom+4));
|
|
const auto secondBottom=dialogControlBounds(window,226).bottom;
|
|
moveRow(229,secondBottom+padding+4);
|
|
layoutDialogButtons(window,229,{IDCANCEL});
|
|
RedrawWindow(window,nullptr,nullptr,RDW_INVALIDATE|RDW_ALLCHILDREN);
|
|
return TRUE;
|
|
}
|
|
if(message==WM_NCHITTEST)
|
|
{
|
|
RECT bounds{};
|
|
GetWindowRect(window,&bounds);
|
|
if(GET_Y_LPARAM(lp)<bounds.top+18)
|
|
{
|
|
SetWindowLongPtrW(window,DWLP_MSGRESULT,HTCAPTION);
|
|
return TRUE;
|
|
}
|
|
}
|
|
if(message!=WM_CLOSE && (message!=WM_COMMAND || LOWORD(wp)!=IDCANCEL)) return FALSE;
|
|
auto &progress=*reinterpret_cast<CopyProgress*>(GetWindowLongPtrW(window,DWLP_USER));
|
|
if(!progress.canceled)
|
|
{
|
|
warningBrush=CreateSolidBrush(RGB(128,0,0));
|
|
const auto answer=DialogBoxParamW(GetModuleHandleW(nullptr),MAKEINTRESOURCEW(105),window,cancelCopyDialog,0);
|
|
DeleteObject(warningBrush);
|
|
warningBrush=nullptr;
|
|
progress.canceled=answer==IDYES;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
struct WarningPrompt
|
|
{
|
|
const wchar_t *message;
|
|
const wchar_t *details;
|
|
const wchar_t *accept;
|
|
const wchar_t *decline;
|
|
bool remember{};
|
|
};
|
|
|
|
LRESULT CALLBACK warningButtonKeys(HWND button,UINT message,WPARAM wp,LPARAM lp,
|
|
UINT_PTR,DWORD_PTR index)
|
|
{
|
|
if(message==WM_GETDLGCODE)
|
|
{
|
|
const auto key=reinterpret_cast<const MSG*>(lp);
|
|
return DefSubclassProc(button,message,wp,lp)|DLGC_WANTARROWS|
|
|
(key && key->message==WM_KEYDOWN && key->wParam==VK_RETURN?DLGC_WANTMESSAGE:0);
|
|
}
|
|
if(message==WM_KEYDOWN && wp==VK_RETURN)
|
|
{
|
|
SendMessageW(button,BM_CLICK,0,0);
|
|
return 0;
|
|
}
|
|
if(message==WM_KEYDOWN && (wp==VK_UP || wp==VK_DOWN))
|
|
{
|
|
if(index<3 && wp==VK_UP) SetFocus(GetDlgItem(GetParent(button),232));
|
|
if(index==3 && wp==VK_DOWN) SetFocus(GetDlgItem(GetParent(button),IDYES));
|
|
return 0;
|
|
}
|
|
if(message==WM_KEYDOWN && index<3 && (wp==VK_LEFT || wp==VK_RIGHT))
|
|
{
|
|
constexpr int buttons[]{IDYES,IDNO,IDCANCEL};
|
|
SetFocus(GetDlgItem(GetParent(button),buttons[(index+(wp==VK_LEFT?2:1))%3]));
|
|
return 0;
|
|
}
|
|
return DefSubclassProc(button,message,wp,lp);
|
|
}
|
|
|
|
INT_PTR CALLBACK warningDialog(HWND window,UINT message,WPARAM wp,LPARAM lp)
|
|
{
|
|
if(message==WM_DRAWITEM && wp==232)
|
|
{
|
|
const auto &item=*reinterpret_cast<const DRAWITEMSTRUCT*>(lp);
|
|
const auto warning=reinterpret_cast<const WarningPrompt*>(GetWindowLongPtrW(window,DWLP_USER));
|
|
auto bounds=item.rcItem;
|
|
FillRect(item.hDC,&bounds,warningBrush);
|
|
SelectObject(item.hDC,mono);
|
|
SetBkMode(item.hDC,TRANSPARENT);
|
|
SetTextColor(item.hDC,RGB(255,255,255));
|
|
bounds.left+=5;
|
|
DrawTextW(item.hDC,warning && warning->remember?L"[x] Remember choice":L"[ ] Remember choice",
|
|
-1,&bounds,DT_SINGLELINE|DT_VCENTER|DT_NOPREFIX);
|
|
if(item.itemState&ODS_FOCUS) DrawFocusRect(item.hDC,&item.rcItem);
|
|
return TRUE;
|
|
}
|
|
if(const auto painted=paintCopyDialog(window,message,wp,lp,L" Warning ",true,{233,234}))
|
|
return painted;
|
|
if(message==WM_INITDIALOG)
|
|
{
|
|
prepareCopyDialog(window);
|
|
SetWindowLongPtrW(window,DWLP_USER,lp);
|
|
const auto &warning=*reinterpret_cast<WarningPrompt*>(lp);
|
|
SetDlgItemTextW(window,230,warning.message);
|
|
SetDlgItemTextW(window,231,warning.details);
|
|
SetDlgItemTextW(window,IDYES,warning.accept);
|
|
SetDlgItemTextW(window,IDNO,warning.decline);
|
|
for(const auto control:{230,231,232})
|
|
SendDlgItemMessageW(window,control,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
|
|
centerDialogRow(window,233,234,{232});
|
|
layoutDialogButtons(window,234,{IDYES,IDNO,IDCANCEL});
|
|
SendMessageW(window,DM_SETDEFID,IDNO,0);
|
|
constexpr int buttons[]{IDYES,IDNO,IDCANCEL};
|
|
for(size_t i=0;i<std::size(buttons);++i)
|
|
SetWindowSubclass(GetDlgItem(window,buttons[i]),warningButtonKeys,1,i);
|
|
SetWindowSubclass(GetDlgItem(window,232),warningButtonKeys,1,std::size(buttons));
|
|
SetFocus(GetDlgItem(window,IDNO));
|
|
return FALSE;
|
|
}
|
|
if(message==WM_CLOSE)
|
|
{
|
|
EndDialog(window,IDCANCEL);
|
|
return TRUE;
|
|
}
|
|
if(message==WM_COMMAND && LOWORD(wp)==232 && HIWORD(wp)==BN_CLICKED)
|
|
{
|
|
auto &warning=*reinterpret_cast<WarningPrompt*>(GetWindowLongPtrW(window,DWLP_USER));
|
|
warning.remember=!warning.remember;
|
|
InvalidateRect(GetDlgItem(window,232),nullptr,FALSE);
|
|
return TRUE;
|
|
}
|
|
if(message==WM_COMMAND && (LOWORD(wp)==IDYES || LOWORD(wp)==IDNO || LOWORD(wp)==IDCANCEL))
|
|
{
|
|
const auto choice=LOWORD(wp);
|
|
EndDialog(window,choice);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
bool pumpCopy(CopyProgress &progress)
|
|
{
|
|
MSG message{};
|
|
while(!progress.canceled && PeekMessageW(&message,nullptr,0,0,PM_REMOVE))
|
|
{
|
|
if(message.message==WM_QUIT)
|
|
{
|
|
PostQuitMessage(static_cast<int>(message.wParam));
|
|
progress.canceled=true;
|
|
break;
|
|
}
|
|
const auto owner=GetWindow(progress.window,GW_OWNER);
|
|
const bool inMainWindow=message.hwnd==owner || IsChild(owner,message.hwnd);
|
|
if(inMainWindow &&
|
|
((message.message>=WM_KEYFIRST && message.message<=WM_KEYLAST) ||
|
|
(message.message>=WM_MOUSEFIRST && message.message<=WM_MOUSELAST)))
|
|
{
|
|
if(message.message==WM_KEYDOWN && message.wParam==VK_ESCAPE)
|
|
SendMessageW(progress.window,WM_COMMAND,IDCANCEL,0);
|
|
else if(message.message==WM_SYSKEYDOWN && message.wParam==VK_F4)
|
|
SendMessageW(owner,WM_CLOSE,0,0);
|
|
continue;
|
|
}
|
|
const bool inProgressWindow=message.hwnd==progress.window || IsChild(progress.window,message.hwnd);
|
|
if(!inProgressWindow || !IsDialogMessageW(progress.window,&message))
|
|
{
|
|
TranslateMessage(&message);
|
|
DispatchMessageW(&message);
|
|
}
|
|
}
|
|
return !progress.canceled;
|
|
}
|
|
|
|
DWORD CALLBACK copyProgressCallback(LARGE_INTEGER total,LARGE_INTEGER transferred,LARGE_INTEGER,LARGE_INTEGER,
|
|
DWORD,DWORD,HANDLE,HANDLE,LPVOID context)
|
|
{
|
|
auto &progress=*static_cast<CopyProgress*>(context);
|
|
updateCopyProgress(progress,transferred.QuadPart,total.QuadPart);
|
|
return pumpCopy(progress)?PROGRESS_CONTINUE:PROGRESS_CANCEL;
|
|
}
|
|
|
|
bool countCopy(const fs::path &path,CopyProgress &progress)
|
|
{
|
|
if(!pumpCopy(progress)) return false;
|
|
WIN32_FILE_ATTRIBUTE_DATA data{};
|
|
if(!GetFileAttributesExW(path.c_str(),GetFileExInfoStandard,&data) ||
|
|
(data.dwFileAttributes&FILE_ATTRIBUTE_REPARSE_POINT)) return false;
|
|
if(!(data.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY))
|
|
{
|
|
++progress.totalFiles;
|
|
progress.totalBytes+=(static_cast<uint64_t>(data.nFileSizeHigh)<<32)|data.nFileSizeLow;
|
|
return true;
|
|
}
|
|
std::error_code error;
|
|
for(fs::directory_iterator it(path,error),end;!error && it!=end;it.increment(error))
|
|
if(!countCopy(it->path(),progress)) return false;
|
|
return !error;
|
|
}
|
|
|
|
enum class CopyResult { complete, skipped, failed };
|
|
|
|
CopyResult copyItem(const fs::path &from,const fs::path &to,CopyProgress &progress)
|
|
{
|
|
if(!pumpCopy(progress)) return CopyResult::failed;
|
|
const auto attributes=GetFileAttributesW(from.c_str());
|
|
if(attributes==INVALID_FILE_ATTRIBUTES || (attributes&FILE_ATTRIBUTE_REPARSE_POINT))
|
|
return CopyResult::failed;
|
|
std::error_code error;
|
|
if(attributes&FILE_ATTRIBUTE_DIRECTORY)
|
|
{
|
|
const auto target=GetFileAttributesW(to.c_str());
|
|
if(target!=INVALID_FILE_ATTRIBUTES &&
|
|
(!(target&FILE_ATTRIBUTE_DIRECTORY) || (target&FILE_ATTRIBUTE_REPARSE_POINT)))
|
|
return CopyResult::failed;
|
|
fs::create_directory(to,error);
|
|
if(error) return CopyResult::failed;
|
|
auto result=CopyResult::complete;
|
|
for(fs::directory_iterator it(from,error),end;!error && it!=end;it.increment(error))
|
|
{
|
|
const auto child=copyItem(it->path(),to/it->path().filename(),progress);
|
|
if(child==CopyResult::failed) return child;
|
|
if(child==CopyResult::skipped) result=child;
|
|
}
|
|
return error?CopyResult::failed:result;
|
|
}
|
|
|
|
progress.from=from;
|
|
progress.to=to;
|
|
const auto fileSize=fs::file_size(from,error);
|
|
if(error) return CopyResult::failed;
|
|
const auto complete=[&]()
|
|
{
|
|
progress.bytes+=fileSize;
|
|
++progress.files;
|
|
updateCopyProgress(progress,0,0);
|
|
return CopyResult::complete;
|
|
};
|
|
const auto skip=[&](const wchar_t *reason)
|
|
{
|
|
progress.skippedBytes+=fileSize;
|
|
++progress.skippedFiles;
|
|
progress.lastSkipReason=reason;
|
|
updateCopyProgress(progress,0,0);
|
|
return CopyResult::skipped;
|
|
};
|
|
updateCopyProgress(progress,0,fileSize);
|
|
if(CopyFileExW(from.c_str(),to.c_str(),copyProgressCallback,&progress,nullptr,COPY_FILE_FAIL_IF_EXISTS))
|
|
return complete();
|
|
const auto code=GetLastError();
|
|
if(progress.canceled || (code!=ERROR_FILE_EXISTS && code!=ERROR_ALREADY_EXISTS && code!=ERROR_ACCESS_DENIED) ||
|
|
fs::equivalent(from,to,error)) return CopyResult::failed;
|
|
WIN32_FILE_ATTRIBUTE_DATA existing{};
|
|
if(!GetFileAttributesExW(to.c_str(),GetFileExInfoStandard,&existing) ||
|
|
(existing.dwFileAttributes&(FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_REPARSE_POINT)))
|
|
return CopyResult::failed;
|
|
const bool readOnly=(existing.dwFileAttributes&FILE_ATTRIBUTE_READONLY)!=0;
|
|
auto mode=progress.conflictMode;
|
|
if(readOnly && progress.askReadOnly) mode=ConflictMode::ask;
|
|
if(mode==ConflictMode::skip) return skip(L"existing file");
|
|
if(mode==ConflictMode::newer)
|
|
{
|
|
WIN32_FILE_ATTRIBUTE_DATA incoming{};
|
|
if(!GetFileAttributesExW(from.c_str(),GetFileExInfoStandard,&incoming)) return CopyResult::failed;
|
|
if(CompareFileTime(&incoming.ftLastWriteTime,&existing.ftLastWriteTime)<=0)
|
|
return skip(L"source is not newer");
|
|
}
|
|
if(mode==ConflictMode::rename)
|
|
{
|
|
for(unsigned index=2;index<=10000;++index)
|
|
{
|
|
const auto name=to.stem().wstring()+L" ("+std::to_wstring(index)+L")"+to.extension().wstring();
|
|
const auto candidate=to.parent_path()/name;
|
|
if(CopyFileExW(from.c_str(),candidate.c_str(),copyProgressCallback,&progress,nullptr,COPY_FILE_FAIL_IF_EXISTS))
|
|
return complete();
|
|
const auto renameError=GetLastError();
|
|
if(progress.canceled || (renameError!=ERROR_FILE_EXISTS && renameError!=ERROR_ALREADY_EXISTS))
|
|
break;
|
|
}
|
|
return CopyResult::failed;
|
|
}
|
|
const bool forceAsk=readOnly && progress.askReadOnly && progress.conflictMode!=ConflictMode::ask;
|
|
auto answer=mode==ConflictMode::ask?(forceAsk?0:static_cast<INT_PTR>(progress.conflictChoice)):IDYES;
|
|
if(!answer)
|
|
{
|
|
WarningPrompt warning{readOnly?L"Existing file is read-only":L"File already exists",
|
|
to.c_str(),L"&Overwrite",L"&Skip"};
|
|
warningBrush=CreateSolidBrush(RGB(128,0,0));
|
|
answer=DialogBoxParamW(GetModuleHandleW(nullptr),MAKEINTRESOURCEW(104),progress.window,
|
|
warningDialog,reinterpret_cast<LPARAM>(&warning));
|
|
if(warning.remember && (answer==IDYES || answer==IDNO))
|
|
progress.conflictChoice=static_cast<int>(answer);
|
|
DeleteObject(warningBrush);
|
|
warningBrush=nullptr;
|
|
}
|
|
if(answer==IDNO) return skip(readOnly?L"read-only conflict":L"conflict choice");
|
|
if(answer!=IDYES)
|
|
{
|
|
progress.canceled=answer==IDCANCEL;
|
|
return CopyResult::failed;
|
|
}
|
|
|
|
GUID id{};
|
|
wchar_t name[40]{};
|
|
if(FAILED(CoCreateGuid(&id)) || !StringFromGUID2(id,name,static_cast<int>(std::size(name))))
|
|
return CopyResult::failed;
|
|
const auto temporary=to.parent_path()/(std::wstring(name)+L".tmp");
|
|
if(mode==ConflictMode::append)
|
|
{
|
|
Handle input{CreateFileW(from.c_str(),GENERIC_READ,FILE_SHARE_READ,nullptr,OPEN_EXISTING,0,nullptr)};
|
|
if(input.value==INVALID_HANDLE_VALUE ||
|
|
!CopyFileExW(to.c_str(),temporary.c_str(),nullptr,nullptr,nullptr,COPY_FILE_FAIL_IF_EXISTS))
|
|
return CopyResult::failed;
|
|
if(readOnly && !SetFileAttributesW(temporary.c_str(),
|
|
(existing.dwFileAttributes&~FILE_ATTRIBUTE_READONLY)|FILE_ATTRIBUTE_ARCHIVE))
|
|
{
|
|
SetFileAttributesW(temporary.c_str(),FILE_ATTRIBUTE_NORMAL);
|
|
DeleteFileW(temporary.c_str());
|
|
return CopyResult::failed;
|
|
}
|
|
bool appended=false;
|
|
{
|
|
Handle output{CreateFileW(temporary.c_str(),FILE_APPEND_DATA,0,nullptr,OPEN_EXISTING,0,nullptr)};
|
|
char buffer[65536];
|
|
uint64_t transferred=0;
|
|
while(output.value!=INVALID_HANDLE_VALUE && pumpCopy(progress))
|
|
{
|
|
DWORD read{},written{};
|
|
if(!ReadFile(input.value,buffer,sizeof(buffer),&read,nullptr)) break;
|
|
if(!read) { appended=true; break; }
|
|
if(!WriteFile(output.value,buffer,read,&written,nullptr) || written!=read) break;
|
|
transferred+=written;
|
|
LARGE_INTEGER total{},done{},unused{};
|
|
total.QuadPart=fileSize;
|
|
done.QuadPart=transferred;
|
|
if(copyProgressCallback(total,done,unused,unused,0,0,nullptr,nullptr,&progress)==PROGRESS_CANCEL) break;
|
|
}
|
|
}
|
|
if(!appended)
|
|
{
|
|
DeleteFileW(temporary.c_str());
|
|
return CopyResult::failed;
|
|
}
|
|
}
|
|
else if(!CopyFileExW(from.c_str(),temporary.c_str(),copyProgressCallback,&progress,nullptr,COPY_FILE_FAIL_IF_EXISTS))
|
|
return CopyResult::failed;
|
|
if(readOnly && !SetFileAttributesW(to.c_str(),existing.dwFileAttributes&~FILE_ATTRIBUTE_READONLY))
|
|
{
|
|
DeleteFileW(temporary.c_str());
|
|
return CopyResult::failed;
|
|
}
|
|
if(MoveFileExW(temporary.c_str(),to.c_str(),MOVEFILE_REPLACE_EXISTING)) return complete();
|
|
if(readOnly) SetFileAttributesW(to.c_str(),existing.dwFileAttributes);
|
|
DeleteFileW(temporary.c_str());
|
|
return CopyResult::failed;
|
|
}
|
|
|
|
void copySelection(HWND owner,Panel &source,Panel &destination)
|
|
{
|
|
if(copyInProgress)
|
|
{
|
|
setStatus(L"A copy is already in progress.");
|
|
return;
|
|
}
|
|
CopyRequest request{{},destination.directory};
|
|
for(size_t i=0;i<source.rows.size();++i)
|
|
if(source.marked[i]) request.sources.push_back(source.rows[i]);
|
|
if(request.sources.empty())
|
|
{
|
|
const auto row=SendMessageW(source.list,LB_GETCURSEL,0,0);
|
|
if(row<0 || static_cast<size_t>(row)>=source.rows.size() || source.sizes[row]==L"Up") return;
|
|
request.sources.push_back(source.rows[row]);
|
|
}
|
|
const auto result=DialogBoxParamW(GetModuleHandleW(nullptr),MAKEINTRESOURCEW(102),owner,copyDialog,
|
|
reinterpret_cast<LPARAM>(&request));
|
|
if(result==-1) setStatus(L"Could not open the Copy dialog.");
|
|
if(result!=IDOK) return;
|
|
|
|
const bool renamed=!request.newName.empty();
|
|
const auto targetDirectory=renamed?request.sources.front().parent_path():request.destination;
|
|
CopyProgress progress;
|
|
progress.conflictMode=request.conflictMode;
|
|
progress.askReadOnly=request.askReadOnly;
|
|
progress.window=CreateDialogParamW(GetModuleHandleW(nullptr),MAKEINTRESOURCEW(103),owner,
|
|
copyProgressDialog,reinterpret_cast<LPARAM>(&progress));
|
|
if(!progress.window)
|
|
{
|
|
setStatus(L"Could not open copy progress.");
|
|
return;
|
|
}
|
|
copyInProgress=true;
|
|
activeCopy=&progress;
|
|
for(auto &panel:panels) EnableWindow(panel.list,FALSE);
|
|
for(const auto command:commands) EnableWindow(command,FALSE);
|
|
GetWindowRect(owner,&previousOwnerBounds);
|
|
ShowWindow(progress.window,SW_SHOW);
|
|
bool failed=false, skipped=false;
|
|
size_t copied=0;
|
|
for(const auto &path:request.sources)
|
|
if(!countCopy(path,progress)) { failed=true; break; }
|
|
updateCopyProgress(progress,0,0,true);
|
|
for(const auto &path:request.sources)
|
|
{
|
|
if(failed) break;
|
|
const auto to=targetDirectory/(renamed?request.newName:path.filename());
|
|
std::error_code error;
|
|
const auto canonicalSource=fs::weakly_canonical(path,error);
|
|
if(error) { failed=true; break; }
|
|
const auto canonicalTarget=fs::weakly_canonical(to,error);
|
|
if(error) { failed=true; break; }
|
|
for(auto ancestor=canonicalTarget;;ancestor=ancestor.parent_path())
|
|
{
|
|
if(CompareStringOrdinal(ancestor.c_str(),-1,canonicalSource.c_str(),-1,TRUE)==CSTR_EQUAL)
|
|
{
|
|
failed=true;
|
|
break;
|
|
}
|
|
if(!ancestor.has_relative_path()) break;
|
|
}
|
|
if(failed) break;
|
|
const auto outcome=copyItem(path,to,progress);
|
|
if(outcome==CopyResult::failed) { failed=true; break; }
|
|
if(outcome==CopyResult::skipped) { skipped=true; continue; }
|
|
++copied;
|
|
const auto row=std::find(source.rows.begin(),source.rows.end(),path);
|
|
if(row!=source.rows.end()) source.marked[row-source.rows.begin()]=false;
|
|
InvalidateRect(source.list,nullptr,FALSE);
|
|
UpdateWindow(source.list);
|
|
}
|
|
const bool restoreFocus=GetForegroundWindow()==progress.window;
|
|
updateCopyProgress(progress,0,0,true);
|
|
RedrawWindow(progress.window,nullptr,nullptr,RDW_UPDATENOW|RDW_ALLCHILDREN);
|
|
DestroyWindow(progress.window);
|
|
activeCopy=nullptr;
|
|
copyInProgress=false;
|
|
for(auto &panel:panels) EnableWindow(panel.list,TRUE);
|
|
for(const auto command:commands) EnableWindow(command,TRUE);
|
|
if(progress.closeOwner)
|
|
{
|
|
PostMessageW(owner,WM_CLOSE,0,0);
|
|
return;
|
|
}
|
|
auto &updated=renamed?source:destination;
|
|
if(updated.directory==targetDirectory && (!renamed || copied))
|
|
open(updated,updated.directory);
|
|
if(restoreFocus)
|
|
{
|
|
SetForegroundWindow(owner);
|
|
SetFocus(panels[active].list);
|
|
}
|
|
if(progress.canceled) setStatus(L"Copy canceled.");
|
|
else if(failed) setStatus(L"Could not complete the copy.");
|
|
else if(skipped) setStatus(L"Copy complete with skipped items.");
|
|
else setStatus(L"Copy complete.");
|
|
}
|
|
|
|
LRESULT CALLBACK panelKeys(HWND window, UINT message, WPARAM wp, LPARAM lp, UINT_PTR, DWORD_PTR index)
|
|
{
|
|
const bool rangeKey=wp==VK_UP || wp==VK_DOWN || wp==VK_LEFT || wp==VK_RIGHT;
|
|
if(message==WM_KEYDOWN && (wp==VK_INSERT || (rangeKey && (GetKeyState(VK_SHIFT)&0x8000))))
|
|
{
|
|
auto &panel=panels[index];
|
|
const auto row=SendMessageW(window,LB_GETCURSEL,0,0);
|
|
if(row<0 || static_cast<size_t>(row)>=panel.marked.size()) return 0;
|
|
const auto last=static_cast<LRESULT>(panel.marked.size()-1);
|
|
auto target=row;
|
|
switch(wp)
|
|
{
|
|
case VK_UP: target=std::max<LRESULT>(0,row-1); break;
|
|
case VK_LEFT: target=0; break;
|
|
case VK_RIGHT: target=last; break;
|
|
default: target=std::min(last,row+1); break;
|
|
}
|
|
const bool mark=!panel.marked[row];
|
|
const bool toBoundary=wp==VK_LEFT || wp==VK_RIGHT;
|
|
const auto first=toBoundary ? std::min(row,target) : row;
|
|
const auto end=toBoundary ? std::max(row,target) : row;
|
|
for(auto i=first;i<=end;++i)
|
|
if(panel.sizes[i]!=L"Up") panel.marked[i]=mark;
|
|
SendMessageW(window,LB_SETCURSEL,target,0);
|
|
InvalidateRect(window,nullptr,FALSE);
|
|
showFileDetails(panel);
|
|
return 0;
|
|
}
|
|
if (message == WM_KEYDOWN && (wp == VK_LEFT || wp == VK_RIGHT))
|
|
return scrollList(window, message, wp == VK_LEFT ? VK_HOME : VK_END, lp);
|
|
if (message == WM_SETFOCUS)
|
|
{
|
|
active = static_cast<int>(index);
|
|
for (int i = 0; i < 2; ++i) InvalidateRect(panels[i].path, nullptr, TRUE);
|
|
showFileDetails(panels[index]);
|
|
}
|
|
if (message == WM_KEYDOWN)
|
|
{
|
|
if ((GetKeyState(VK_CONTROL)&0x8000) && (wp==L'1' || wp==L'4'))
|
|
{
|
|
setMode(static_cast<int>(index),wp==L'4');
|
|
return 0;
|
|
}
|
|
if (wp == VK_TAB) { SetFocus(panels[1 - index].list); return 0; }
|
|
if (wp == VK_RETURN) { enter(panels[index]); return 0; }
|
|
if (wp == VK_F2) { open(panels[index], panels[index].directory); return 0; }
|
|
if (wp == VK_F10) { SendMessageW(GetParent(window), WM_CLOSE, 0, 0); return 0; }
|
|
if (wp == VK_F3 || wp == VK_F4)
|
|
{
|
|
const auto &panel = panels[index];
|
|
auto row = SendMessageW(window, LB_GETCURSEL, 0, 0);
|
|
if (row < 0 || static_cast<size_t>(row) >= panel.rows.size()) return 0;
|
|
const auto &file = panel.rows[row];
|
|
std::error_code error;
|
|
if (!fs::is_regular_file(file, error)) return 0;
|
|
auto verb = wp == VK_F4 ? L"edit" : L"open";
|
|
if (reinterpret_cast<INT_PTR>(ShellExecuteW(GetParent(window), verb, file.c_str(), nullptr,
|
|
panel.directory.c_str(), SW_SHOWNORMAL)) <= 32)
|
|
setStatus(wp == VK_F4 ? L"No editor is registered for this file." : L"Cannot open the selected file.");
|
|
return 0;
|
|
}
|
|
if (wp == VK_F5)
|
|
{
|
|
copySelection(GetParent(window),panels[index],panels[1-index]);
|
|
return 0;
|
|
}
|
|
}
|
|
auto result=scrollList(window, message, wp, lp);
|
|
if(message==WM_PAINT && panels[index].wide)
|
|
{
|
|
auto dc=GetDC(window);
|
|
if(dc)
|
|
{
|
|
RECT line{};
|
|
GetClientRect(window,&line);
|
|
line.left=std::max(0L,line.right-(sizeWidth+2)*static_cast<LONG>(cellWidth));
|
|
line.right=line.left+1;
|
|
SetDCBrushColor(dc,colors[Frame]);
|
|
FillRect(dc,&line,static_cast<HBRUSH>(GetStockObject(DC_BRUSH)));
|
|
ReleaseDC(window,dc);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
INT_PTR CALLBACK wideModeDialog(HWND dialog, UINT message, WPARAM wp, LPARAM)
|
|
{
|
|
constexpr int widthField=201, extensionsField=202, detailsField=203;
|
|
if(message==WM_INITDIALOG)
|
|
{
|
|
SetDlgItemInt(dialog,widthField,sizeWidth,FALSE);
|
|
SendDlgItemMessageW(dialog,widthField,EM_SETLIMITTEXT,2,0);
|
|
CheckDlgButton(dialog,extensionsField,alignExtensions?BST_CHECKED:BST_UNCHECKED);
|
|
CheckDlgButton(dialog,detailsField,showDetails?BST_CHECKED:BST_UNCHECKED);
|
|
CheckDlgButton(dialog,204,alignFolders?BST_CHECKED:BST_UNCHECKED);
|
|
for(int i=0;i<4;++i) CheckDlgButton(dialog,205+i,(statusFields&(1u<<i))?BST_CHECKED:BST_UNCHECKED);
|
|
return TRUE;
|
|
}
|
|
if(message==WM_CLOSE || (message==WM_COMMAND && LOWORD(wp)==IDCANCEL))
|
|
{
|
|
EndDialog(dialog,IDCANCEL);
|
|
return TRUE;
|
|
}
|
|
if(message!=WM_COMMAND || LOWORD(wp)!=IDOK) return FALSE;
|
|
BOOL valid{};
|
|
auto width=GetDlgItemInt(dialog,widthField,&valid,FALSE);
|
|
if(!valid || width<6 || width>16)
|
|
{
|
|
MessageBoxW(dialog,L"Enter a width from 6 to 16 characters.",L"Wide panel mode",MB_OK|MB_ICONWARNING);
|
|
SetFocus(GetDlgItem(dialog,widthField));
|
|
SendDlgItemMessageW(dialog,widthField,EM_SETSEL,0,-1);
|
|
return TRUE;
|
|
}
|
|
sizeWidth=static_cast<int>(width);
|
|
alignExtensions=IsDlgButtonChecked(dialog,extensionsField)==BST_CHECKED;
|
|
showDetails=IsDlgButtonChecked(dialog,detailsField)==BST_CHECKED;
|
|
alignFolders=IsDlgButtonChecked(dialog,204)==BST_CHECKED;
|
|
statusFields=0;
|
|
for(int i=0;i<4;++i) if(IsDlgButtonChecked(dialog,205+i)==BST_CHECKED) statusFields|=1u<<i;
|
|
savePreference(L"SizeWidth",sizeWidth);
|
|
savePreference(L"AlignExtensions",alignExtensions);
|
|
savePreference(L"ShowDetails",showDetails);
|
|
savePreference(L"AlignFolders",alignFolders);
|
|
savePreference(L"StatusFields",statusFields);
|
|
EndDialog(dialog,IDOK);
|
|
return TRUE;
|
|
}
|
|
|
|
void editWideMode(HWND owner)
|
|
{
|
|
const auto result=DialogBoxParamW(GetModuleHandleW(nullptr),MAKEINTRESOURCEW(101),owner,wideModeDialog,0);
|
|
if(result==IDOK)
|
|
{
|
|
for(auto &panel:panels)
|
|
{
|
|
InvalidateRect(panel.list,nullptr,TRUE);
|
|
InvalidateRect(panel.heading,nullptr,TRUE);
|
|
}
|
|
showFileDetails(panels[active]);
|
|
}
|
|
else if(result==-1) setStatus(L"Could not open Wide panel settings.");
|
|
}
|
|
|
|
void openMenu(HWND window, int index, int page)
|
|
{
|
|
menuIndex=index;
|
|
optionsPage=page;
|
|
commandPicker=true;
|
|
SendMessageW(picker,LB_RESETCONTENT,0,0);
|
|
std::vector<std::wstring> rows;
|
|
if(index==0 || index==4)
|
|
{
|
|
const bool wide=panels[index==4].wide;
|
|
rows={wide?L" Brief\tCtrl+1":L"✓ Brief\tCtrl+1",
|
|
wide?L"✓ Wide\tCtrl+4":L" Wide\tCtrl+4",
|
|
index==0?L" Change drive\tAlt+F1":L" Change drive\tAlt+F2"};
|
|
}
|
|
else if(index==1) rows={L"Copy\tF5",L"Exit\tF10"};
|
|
else if(index==2) rows={L"Refresh\tF2",L"View\tF3",L"Edit\tF4"};
|
|
else if(page==0) rows={L"File panel modes",L"Colors",L"Appearance…"};
|
|
else if(page==1) rows={L"Wide"};
|
|
else if(page==2) rows={L"Panel background",L"Text",L"Frame",L"Popup background",
|
|
L"Menu selection",L"Command bar",L"File cursor"};
|
|
for(const auto &row:rows)
|
|
SendMessageW(picker,LB_ADDSTRING,0,reinterpret_cast<LPARAM>(row.c_str()));
|
|
RECT anchor{}, client{};
|
|
GetWindowRect(menuItems[index],&anchor);
|
|
MapWindowPoints(nullptr,window,reinterpret_cast<POINT*>(&anchor),2);
|
|
GetClientRect(window,&client);
|
|
const int width=std::min(static_cast<int>(client.right)-16,26*cellWidth+16);
|
|
const int x=std::clamp(static_cast<int>(anchor.left)+4,4,std::max(4,static_cast<int>(client.right)-width-12));
|
|
const int y=anchor.bottom+5;
|
|
const int height=static_cast<int>(rows.size())*static_cast<int>(SendMessageW(picker,LB_GETITEMHEIGHT,0,0));
|
|
SetWindowPos(pickerFrame,HWND_TOP,x-4,y-4,width+13,height+8,SWP_SHOWWINDOW);
|
|
SetWindowPos(picker,HWND_TOP,x,y,width,height,SWP_SHOWWINDOW);
|
|
SendMessageW(picker,LB_SETCURSEL,0,0);
|
|
SetFocus(picker);
|
|
showMenu(true);
|
|
}
|
|
|
|
LRESULT CALLBACK filesWindow(HWND window, UINT message, WPARAM wp, LPARAM lp)
|
|
{
|
|
switch (message)
|
|
{
|
|
case WM_CREATE:
|
|
{
|
|
auto instance = GetModuleHandleW(nullptr);
|
|
LOGFONTW font{};
|
|
DWORD bytes=sizeof(font);
|
|
if(RegGetValueW(HKEY_CURRENT_USER,schemeKey,L"DisplayFont",RRF_RT_REG_BINARY,nullptr,&font,&bytes)
|
|
!=ERROR_SUCCESS || bytes!=sizeof(font))
|
|
{
|
|
font={};
|
|
font.lfWeight=FW_NORMAL;
|
|
font.lfCharSet=DEFAULT_CHARSET;
|
|
font.lfQuality=CLEARTYPE_QUALITY;
|
|
wcscpy_s(font.lfFaceName,L"Consolas");
|
|
}
|
|
font.lfFaceName[LF_FACESIZE-1]=0;
|
|
if(!applyFont(window,font,static_cast<int>(std::clamp(preference(L"FontPoints",110),80UL,240UL)))) return -1;
|
|
loadColors();
|
|
panels[0].wide=preference(L"LeftWide",0)!=0;
|
|
panels[1].wide=preference(L"RightWide",0)!=0;
|
|
sizeWidth=static_cast<int>(std::clamp(preference(L"SizeWidth",6),6UL,16UL));
|
|
alignExtensions=preference(L"AlignExtensions",1)!=0;
|
|
showDetails=preference(L"ShowDetails",1)!=0;
|
|
alignFolders=preference(L"AlignFolders",0)!=0;
|
|
statusFields=preference(L"StatusFields",15)&15;
|
|
menuBar=CreateWindowW(L"BUTTON",L"",WS_CHILD|WS_CLIPSIBLINGS|BS_OWNERDRAW,
|
|
0,0,0,0,window,reinterpret_cast<HMENU>(120),instance,nullptr);
|
|
const wchar_t *menus[]{L"Left",L"Files",L"Commands",L"Options",L"Right"};
|
|
for(int i=0;i<5;++i)
|
|
{
|
|
menuItems[i]=CreateWindowW(L"BUTTON",menus[i],WS_CHILD|WS_CLIPSIBLINGS|BS_OWNERDRAW,
|
|
0,0,0,0,window,reinterpret_cast<HMENU>(130+static_cast<INT_PTR>(i)),instance,nullptr);
|
|
if(!menuItems[i]) return -1;
|
|
}
|
|
picker=CreateWindowExW(0,L"LISTBOX",L"Change drive",
|
|
WS_CHILD|WS_CLIPSIBLINGS|LBS_NOTIFY|LBS_OWNERDRAWFIXED|LBS_HASSTRINGS|LBS_NOINTEGRALHEIGHT,
|
|
0,0,0,0,window,reinterpret_cast<HMENU>(121),instance,nullptr);
|
|
pickerFrame=CreateWindowW(L"STATIC",L"",WS_CHILD|WS_CLIPSIBLINGS|SS_OWNERDRAW,
|
|
0,0,0,0,window,reinterpret_cast<HMENU>(122),instance,nullptr);
|
|
SetWindowSubclass(picker,pickerKeys,1,0);
|
|
SendMessageW(picker,LB_SETITEMHEIGHT,0,textHeight);
|
|
status = CreateWindowW(L"STATIC", L"", WS_CHILD | WS_VISIBLE | SS_PATHELLIPSIS,
|
|
0, 0, 0, 0, window, nullptr, instance, nullptr);
|
|
if (!mono || !blue || !teal || !menuBar || !picker || !pickerFrame || !status) return -1;
|
|
SendMessageW(status, WM_SETFONT, reinterpret_cast<WPARAM>(mono), FALSE);
|
|
const wchar_t *labels[]{L"F2 Refresh", L"F3 View", L"F4 Edit", L"F5 Copy", L"F10 Exit"};
|
|
for (int i = 0; i < 5; ++i)
|
|
commands[i] = CreateWindowW(L"BUTTON", labels[i], WS_CHILD | WS_VISIBLE | BS_OWNERDRAW,
|
|
0, 0, 0, 0, window, reinterpret_cast<HMENU>(110 + static_cast<INT_PTR>(i)), instance, nullptr);
|
|
for (int i = 0; i < 2; ++i)
|
|
{
|
|
auto &panel = panels[i];
|
|
panel.path = CreateWindowW(L"STATIC", L"", WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | SS_PATHELLIPSIS,
|
|
0, 0, 0, 0, window, nullptr, instance, nullptr);
|
|
panel.list = CreateWindowExW(0, L"LISTBOX", L"",
|
|
WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | LBS_NOTIFY | LBS_NOINTEGRALHEIGHT | LBS_OWNERDRAWFIXED | LBS_HASSTRINGS,
|
|
0, 0, 0, 0, window, reinterpret_cast<HMENU>(102 + static_cast<INT_PTR>(i)), instance, nullptr);
|
|
panel.heading=CreateWindowW(L"STATIC",L"",WS_CHILD|WS_CLIPSIBLINGS|SS_OWNERDRAW,
|
|
0,0,0,0,window,reinterpret_cast<HMENU>(140+static_cast<INT_PTR>(i)),instance,nullptr);
|
|
if (!panel.path || !panel.list || !panel.heading) return -1;
|
|
for (auto child : {panel.path, panel.list})
|
|
SendMessageW(child, WM_SETFONT, reinterpret_cast<WPARAM>(mono), FALSE);
|
|
SendMessageW(panel.list,LB_SETITEMHEIGHT,0,textHeight);
|
|
wchar_t system[MAX_PATH]{};
|
|
GetWindowsDirectoryW(system, MAX_PATH);
|
|
const auto saved=savedPanelPath(panelPathKeys[i]);
|
|
if(saved.is_absolute()) open(panel,saved);
|
|
if(!panel.directory.empty())
|
|
{
|
|
const auto cursor=savedPanelPath(panelCursorKeys[i]);
|
|
const auto row=std::find(panel.rows.begin(),panel.rows.end(),cursor);
|
|
if(row!=panel.rows.end()) SendMessageW(panel.list,LB_SETCURSEL,row-panel.rows.begin(),0);
|
|
}
|
|
if(panel.directory.empty()) open(panel,fs::path(system).root_path());
|
|
SetWindowSubclass(panel.list, panelKeys, 1, i);
|
|
}
|
|
SetFocus(panels[0].list);
|
|
return 0;
|
|
}
|
|
case WM_DPICHANGED:
|
|
{
|
|
hidePicker();
|
|
const auto &bounds=*reinterpret_cast<const RECT*>(lp);
|
|
applyFont(window,displayFont,fontPoints);
|
|
SetWindowPos(window,nullptr,bounds.left,bounds.top,bounds.right-bounds.left,
|
|
bounds.bottom-bounds.top,SWP_NOZORDER|SWP_NOACTIVATE);
|
|
layout(window);
|
|
if(activeCopy) PostMessageW(activeCopy->window,refreshProgressLayout,0,0);
|
|
RedrawWindow(window,nullptr,nullptr,RDW_INVALIDATE|RDW_ALLCHILDREN);
|
|
return 0;
|
|
}
|
|
case WM_MOVE:
|
|
if(copyInProgress && !IsIconic(window))
|
|
{
|
|
RECT bounds{};
|
|
if(GetWindowRect(window,&bounds))
|
|
{
|
|
const OwnedWindowMove move{window,bounds.left-previousOwnerBounds.left,
|
|
bounds.top-previousOwnerBounds.top};
|
|
previousOwnerBounds=bounds;
|
|
if(move.dx || move.dy)
|
|
EnumThreadWindows(GetCurrentThreadId(),moveOwnedDialog,reinterpret_cast<LPARAM>(&move));
|
|
}
|
|
}
|
|
return 0;
|
|
case WM_SIZE:
|
|
hidePicker();
|
|
layout(window);
|
|
return 0;
|
|
case WM_GETMINMAXINFO:
|
|
reinterpret_cast<MINMAXINFO *>(lp)->ptMinTrackSize = {540, 220};
|
|
return 0;
|
|
case WM_SETCURSOR:
|
|
case WM_LBUTTONDOWN:
|
|
{
|
|
POINT point{};
|
|
GetCursorPos(&point);
|
|
ScreenToClient(window, &point);
|
|
RECT rect{};
|
|
GetClientRect(window, &rect);
|
|
const int width = rect.right;
|
|
int middle = std::clamp(split ? split : width / 2, 120, std::max(120, width - 120));
|
|
if (point.y >= 0 && point.y < rect.bottom-2*textHeight-14 && abs(point.x - middle) <= 4)
|
|
{
|
|
SetCursor(LoadCursorW(nullptr, IDC_SIZEWE));
|
|
if (message == WM_LBUTTONDOWN) { dragging = true; SetCapture(window); }
|
|
return TRUE;
|
|
}
|
|
break;
|
|
}
|
|
case WM_MOUSEMOVE:
|
|
if (dragging) { split = std::max(1, GET_X_LPARAM(lp)); layout(window); }
|
|
return 0;
|
|
case WM_LBUTTONUP:
|
|
if (dragging) ReleaseCapture();
|
|
return 0;
|
|
case WM_CAPTURECHANGED:
|
|
dragging = false;
|
|
return 0;
|
|
case WM_ERASEBKGND:
|
|
return 1;
|
|
case WM_PAINT:
|
|
{
|
|
PAINTSTRUCT paint{};
|
|
auto dc=BeginPaint(window,&paint);
|
|
FillRect(dc,&paint.rcPaint,blue);
|
|
auto border=CreateSolidBrush(colors[Frame]);
|
|
for(const auto &panel:panels)
|
|
{
|
|
RECT box{};
|
|
GetWindowRect(panel.list,&box);
|
|
MapWindowPoints(nullptr,window,reinterpret_cast<POINT*>(&box),2);
|
|
box.right+=5;
|
|
InflateRect(&box,2,2);
|
|
FrameRect(dc,&box,border);
|
|
paintScrollPosition(window,dc,panel.list,colors[PanelBlue]);
|
|
InflateRect(&box,-1,-1);
|
|
FrameRect(dc,&box,border);
|
|
}
|
|
DeleteObject(border);
|
|
EndPaint(window,&paint);
|
|
return 0;
|
|
}
|
|
case WM_CTLCOLORSTATIC:
|
|
{
|
|
auto dc=reinterpret_cast<HDC>(wp);
|
|
bool highlighted=reinterpret_cast<HWND>(lp)==panels[active].path;
|
|
SetTextColor(dc,colors[highlighted?Text:Frame]);
|
|
SetBkColor(dc,colors[highlighted?Dialog:PanelBlue]);
|
|
return reinterpret_cast<LRESULT>(highlighted?teal:blue);
|
|
}
|
|
case WM_CTLCOLORLISTBOX:
|
|
return reinterpret_cast<LRESULT>(reinterpret_cast<HWND>(lp)==picker?teal:blue);
|
|
case WM_DRAWITEM:
|
|
{
|
|
const auto &item=*reinterpret_cast<const DRAWITEMSTRUCT *>(lp);
|
|
if(item.CtlID==140 || item.CtlID==141)
|
|
{
|
|
auto name=item.rcItem, size=item.rcItem;
|
|
size.left=std::max(size.left,size.right-(sizeWidth+2)*static_cast<LONG>(cellWidth));
|
|
name.right=size.left;
|
|
paintText(item.hDC,name,L"Name",RGB(255,255,0),colors[PanelBlue]);
|
|
paintText(item.hDC,size,L"Size",RGB(255,255,0),colors[PanelBlue],true);
|
|
RECT line{size.left,size.top,size.left+1,size.bottom};
|
|
SetDCBrushColor(item.hDC,colors[Frame]);
|
|
FillRect(item.hDC,&line,static_cast<HBRUSH>(GetStockObject(DC_BRUSH)));
|
|
return TRUE;
|
|
}
|
|
if(item.hwndItem==pickerFrame)
|
|
{
|
|
auto box=item.rcItem;
|
|
FillRect(item.hDC,&box,teal);
|
|
auto border=CreateSolidBrush(colors[Frame]);
|
|
InflateRect(&box,-2,-2);
|
|
FrameRect(item.hDC,&box,border);
|
|
InflateRect(&box,-2,-2);
|
|
FrameRect(item.hDC,&box,border);
|
|
DeleteObject(border);
|
|
if(commandPicker) return TRUE;
|
|
box.left+=9;
|
|
box.right=std::min(box.right,box.left+13*cellWidth);
|
|
box.bottom=box.top+textHeight;
|
|
paintText(item.hDC,box,L"Change drive",colors[Text],colors[Dialog]);
|
|
paintScrollPosition(pickerFrame,item.hDC,picker,colors[Dialog]);
|
|
return TRUE;
|
|
}
|
|
std::wstring text;
|
|
if(item.CtlType==ODT_LISTBOX && item.itemID!=UINT(-1))
|
|
{
|
|
auto length=SendMessageW(item.hwndItem,LB_GETTEXTLEN,item.itemID,0);
|
|
if(length>=0)
|
|
{
|
|
text.resize(length+1);
|
|
SendMessageW(item.hwndItem,LB_GETTEXT,item.itemID,reinterpret_cast<LPARAM>(text.data()));
|
|
}
|
|
}
|
|
if(item.CtlType==ODT_BUTTON)
|
|
{
|
|
wchar_t label[64]{};
|
|
GetWindowTextW(item.hwndItem,label,64);
|
|
text=label;
|
|
}
|
|
auto background=item.CtlType==ODT_BUTTON?Footer:item.hwndItem==picker?Dialog:PanelBlue;
|
|
auto foreground=colors[Text];
|
|
if(item.CtlID>=130 && item.CtlID<=134 && static_cast<int>(item.CtlID)-130==menuIndex)
|
|
background=Selection;
|
|
if(item.itemState&(ODS_SELECTED|ODS_FOCUS))
|
|
background=item.CtlType==ODT_LISTBOX && item.hwndItem!=picker?PanelCursor:Selection;
|
|
if(item.CtlID==102 || item.CtlID==103)
|
|
{
|
|
const auto &panel=panels[item.CtlID-102];
|
|
if(item.itemID<panel.marked.size() && panel.marked[item.itemID])
|
|
foreground=RGB(255,255,0);
|
|
else if(item.itemID<panel.dimmed.size() && panel.dimmed[item.itemID])
|
|
{
|
|
auto bg=colors[background];
|
|
foreground=RGB((3*GetRValue(foreground)+2*GetRValue(bg))/5,
|
|
(3*GetGValue(foreground)+2*GetGValue(bg))/5,
|
|
(3*GetBValue(foreground)+2*GetBValue(bg))/5);
|
|
}
|
|
}
|
|
auto shortcut=text.find(L'\t');
|
|
if(item.hwndItem==picker && commandPicker && shortcut!=text.npos)
|
|
{
|
|
auto labelRect=item.rcItem, keyRect=item.rcItem;
|
|
SelectObject(item.hDC,mono);
|
|
SIZE extent{};
|
|
const auto key=text.c_str()+shortcut+1;
|
|
GetTextExtentPoint32W(item.hDC,key,lstrlenW(key),&extent);
|
|
keyRect.left=std::max(keyRect.left,keyRect.right-extent.cx-16);
|
|
labelRect.right=keyRect.left;
|
|
paintText(item.hDC,labelRect,text.substr(0,shortcut).c_str(),colors[Text],colors[background]);
|
|
paintText(item.hDC,keyRect,key,colors[Text],colors[background],true);
|
|
}
|
|
else paintText(item.hDC,item.rcItem,text.c_str(),foreground,colors[background]);
|
|
if(item.CtlID==102 || item.CtlID==103)
|
|
{
|
|
const auto &panel=panels[item.CtlID-102];
|
|
if(panel.wide && item.itemID<panel.sizes.size())
|
|
{
|
|
auto name=item.rcItem, size=item.rcItem;
|
|
size.left=std::max(size.left,size.right-(sizeWidth+2)*static_cast<LONG>(cellWidth));
|
|
name.right=size.left;
|
|
bool folder=panel.sizes[item.itemID]==L"Folder";
|
|
if(folder) text=panel.rows[item.itemID].filename().wstring();
|
|
if(panel.sizes[item.itemID]!=L"Up" && (folder?alignFolders:alignExtensions))
|
|
{
|
|
auto extension=panel.rows[item.itemID].extension().wstring();
|
|
if(!extension.empty())
|
|
{
|
|
auto end=name;
|
|
end.left=std::max(end.left,end.right-8*static_cast<LONG>(cellWidth));
|
|
name.right=end.left;
|
|
paintText(item.hDC,end,extension.c_str()+1,foreground,colors[background],true);
|
|
text=panel.rows[item.itemID].stem().wstring();
|
|
}
|
|
}
|
|
paintText(item.hDC,name,text.c_str(),foreground,colors[background]);
|
|
const auto &amount=panel.sizes[item.itemID];
|
|
auto visible=amount;
|
|
if(amount!=L"Folder" && amount!=L"Up")
|
|
visible=formatSize(std::stoull(amount),static_cast<size_t>(sizeWidth));
|
|
paintText(item.hDC,size,visible.c_str(),foreground,colors[background],true);
|
|
RECT line{size.left,size.top,size.left+1,size.bottom};
|
|
SetDCBrushColor(item.hDC,colors[Frame]);
|
|
FillRect(item.hDC,&line,static_cast<HBRUSH>(GetStockObject(DC_BRUSH)));
|
|
}
|
|
}
|
|
if (item.CtlType==ODT_LISTBOX)
|
|
{
|
|
RECT track{};
|
|
GetWindowRect(item.hwndItem,&track);
|
|
auto owner=item.hwndItem==picker?pickerFrame:window;
|
|
MapWindowPoints(nullptr,owner,reinterpret_cast<POINT*>(&track),2);
|
|
track.left=track.right;
|
|
track.right+=5;
|
|
InvalidateRect(owner,&track,FALSE);
|
|
}
|
|
return TRUE;
|
|
}
|
|
case WM_COMMAND:
|
|
if(LOWORD(wp)==121 && HIWORD(wp)==LBN_DBLCLK) selectDrive();
|
|
if(LOWORD(wp)>=130 && LOWORD(wp)<=134 && HIWORD(wp)==BN_CLICKED)
|
|
{
|
|
openMenu(window,LOWORD(wp)-130);
|
|
return 0;
|
|
}
|
|
if (LOWORD(wp) >= 110 && LOWORD(wp) <= 114 && HIWORD(wp) == BN_CLICKED)
|
|
{
|
|
const WPARAM keys[]{VK_F2, VK_F3, VK_F4, VK_F5, VK_F10};
|
|
SetFocus(panels[active].list);
|
|
SendMessageW(panels[active].list, WM_KEYDOWN, keys[LOWORD(wp) - 110], 0);
|
|
}
|
|
if (LOWORD(wp) >= 102 && LOWORD(wp) <= 103 && HIWORD(wp) == LBN_DBLCLK)
|
|
enter(panels[LOWORD(wp) - 102]);
|
|
if (LOWORD(wp) >= 102 && LOWORD(wp) <= 103 && HIWORD(wp) == LBN_SELCHANGE)
|
|
showFileDetails(panels[LOWORD(wp) - 102]);
|
|
return 0;
|
|
case WM_CLOSE:
|
|
if(activeCopy)
|
|
{
|
|
if(!IsWindowEnabled(activeCopy->window))
|
|
{
|
|
setStatus(L"Resolve the copy prompt before closing.");
|
|
return 0;
|
|
}
|
|
SendMessageW(activeCopy->window,WM_COMMAND,IDCANCEL,0);
|
|
activeCopy->closeOwner=activeCopy->canceled;
|
|
return 0;
|
|
}
|
|
savePlacement(window);
|
|
for(int i=0;i<2;++i)
|
|
{
|
|
const auto &path=panels[i].directory.native();
|
|
if(!path.empty())
|
|
RegSetKeyValueW(HKEY_CURRENT_USER,schemeKey,panelPathKeys[i],REG_SZ,path.c_str(),
|
|
static_cast<DWORD>((path.size()+1)*sizeof(wchar_t)));
|
|
const auto row=SendMessageW(panels[i].list,LB_GETCURSEL,0,0);
|
|
const auto cursor=row>=0 && static_cast<size_t>(row)<panels[i].rows.size() ?
|
|
panels[i].rows[row].native() : std::wstring{};
|
|
RegSetKeyValueW(HKEY_CURRENT_USER,schemeKey,panelCursorKeys[i],REG_SZ,cursor.c_str(),
|
|
static_cast<DWORD>((cursor.size()+1)*sizeof(wchar_t)));
|
|
}
|
|
DestroyWindow(window);
|
|
return 0;
|
|
case WM_DESTROY:
|
|
PostQuitMessage(0);
|
|
return 0;
|
|
}
|
|
return DefWindowProcW(window, message, wp, lp);
|
|
}
|
|
}
|
|
|
|
int WINAPI wWinMain(HINSTANCE instance, HINSTANCE, PWSTR, int show)
|
|
{
|
|
int count{};
|
|
if(auto args=CommandLineToArgvW(GetCommandLineW(),&count))
|
|
{
|
|
if(count==4 && std::wstring_view(args[1])==L"--list-folder")
|
|
{
|
|
auto result=listElevatedFolder(fs::path(args[2]).parent_path(),args[3]);
|
|
LocalFree(args);
|
|
return static_cast<int>(result);
|
|
}
|
|
LocalFree(args);
|
|
}
|
|
INITCOMMONCONTROLSEX controls{sizeof(controls), ICC_STANDARD_CLASSES|ICC_PROGRESS_CLASS};
|
|
InitCommonControlsEx(&controls);
|
|
WNDCLASSW type{};
|
|
type.hInstance = instance;
|
|
type.lpfnWndProc = filesWindow;
|
|
type.hIcon = LoadIconW(instance, MAKEINTRESOURCEW(1));
|
|
type.hCursor = LoadCursorW(nullptr, IDC_ARROW);
|
|
|
|
type.lpszClassName = L"KSwitcher.Files";
|
|
if (!RegisterClassW(&type)) return 1;
|
|
auto window = CreateWindowW(type.lpszClassName, L"KSwitcher Files — local prototype",
|
|
WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN, CW_USEDEFAULT, CW_USEDEFAULT, 900, 540, nullptr, nullptr, instance, nullptr);
|
|
if (!window) return 1;
|
|
if(!restorePlacement(window)) ShowWindow(window, show);
|
|
MSG message{};
|
|
while (GetMessageW(&message, nullptr, 0, 0) > 0)
|
|
{
|
|
if (message.message == WM_SYSKEYDOWN && message.wParam == VK_MENU)
|
|
{
|
|
altAlone=true;
|
|
continue;
|
|
}
|
|
if ((message.message == WM_SYSKEYUP || message.message == WM_KEYUP) && message.wParam == VK_MENU)
|
|
{
|
|
if(altAlone)
|
|
{
|
|
hidePicker();
|
|
menuIndex=active==0?0:4;
|
|
showMenu(true);
|
|
}
|
|
altAlone=false;
|
|
continue;
|
|
}
|
|
if(message.message==WM_SYSKEYDOWN || message.message==WM_KEYDOWN) altAlone=false;
|
|
if((message.message==WM_LBUTTONDOWN || message.message==WM_RBUTTONDOWN ||
|
|
message.message==WM_NCLBUTTONDOWN) && message.hwnd!=menuBar && message.hwnd!=picker &&
|
|
std::find(std::begin(menuItems),std::end(menuItems),message.hwnd)==std::end(menuItems))
|
|
{
|
|
showMenu(false);
|
|
if(message.hwnd!=picker) hidePicker();
|
|
}
|
|
if(message.message==WM_KEYDOWN && IsWindowVisible(menuBar) && !IsWindowVisible(picker))
|
|
{
|
|
if(message.wParam==VK_ESCAPE){showMenu(false);SetFocus(panels[active].list);continue;}
|
|
if(message.wParam==VK_LEFT || message.wParam==VK_RIGHT)
|
|
{
|
|
menuIndex=(menuIndex+(message.wParam==VK_LEFT?4:1))%5;
|
|
showMenu(true);
|
|
continue;
|
|
}
|
|
if(message.wParam==VK_RETURN || message.wParam==VK_DOWN)
|
|
{
|
|
SendMessageW(window,WM_COMMAND,MAKEWPARAM(130+menuIndex,BN_CLICKED),0);
|
|
continue;
|
|
}
|
|
}
|
|
if (message.message == WM_SYSKEYDOWN && message.wParam == VK_F10 &&
|
|
!(GetKeyState(VK_MENU) & 0x8000) && !(GetKeyState(VK_SHIFT) & 0x8000))
|
|
{
|
|
SendMessageW(window, WM_CLOSE, 0, 0);
|
|
continue;
|
|
}
|
|
if (message.message == WM_SYSKEYDOWN && (message.wParam == VK_F1 || message.wParam == VK_F2))
|
|
{
|
|
chooseDrive(static_cast<int>(message.wParam - VK_F1));
|
|
continue;
|
|
}
|
|
TranslateMessage(&message);
|
|
DispatchMessageW(&message);
|
|
}
|
|
DeleteObject(mono);
|
|
DeleteObject(blue);
|
|
DeleteObject(teal);
|
|
return 0;
|
|
}
|